query-interface-server 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fed8b7439d3f2e04a839c1ba53a70b7571a90d17
-  data.tar.gz: 3baa596556cff58beee39a24b581694ea5a8166c
+  metadata.gz: 31d192d0acccf634f378134910fae9a2d0856aa2
+  data.tar.gz: d777536d9062e1dfd91017e6749ae92303bd4a21
 SHA512:
-  metadata.gz: 0dcbd75eff1e6b87cf0865e28a36596fa313f6661af0cc7573c8974544689820e75d96fe9c6b9277eb059719a47fec8489030ffeef1b36a78e14db316c8fece2
-  data.tar.gz: 2e37f8e37a7e9fb64a771d650dd231d8c70fd2112e9afbe483eacbe7fa790b29d1d2617a120b329f9001c2dafd4b273746e4ca2ba6e4ae5061bacd92379ec2b3
+  metadata.gz: 6f5c49b92e0edc9ab581facf8e74e3f7051e56bd6060fa427baf56378bc38bb23d12b1560b85eadd1cd2ba02a8699920d4b192966173e837c39d9571189fb8e7
+  data.tar.gz: 89a73932e4564bb2584de61f094934846dd524cb7f2579604fc812ecb13fe3dae53bc28989f180649bf3b7a4deb96be313c077d80cef75c5a962c06819c8fa66

data/lib/query-interface-server.rb

@@ -1,3 +1,6 @@
 require 'sequel'
 
 require 'query-interface-server/resource'
+require 'query-interface-server/lazy_query'
+require 'query-interface-server/transformations'
+require 'query-interface-server/transformations/sequel_transformer'

data/lib/query-interface-server/lazy_query.rb

@@ -0,0 +1,120 @@
+module QueryInterface
+  module Server
+    class LazyQuery
+
+      attr_accessor :model, :result_model, :transformations
+
+      def initialize(model, transformations=nil, result_model=nil)
+        self.model = model
+        if transformations
+          self.transformations = transformations.map {|item| item.dup}
+        else
+          self.transformations = []
+        end
+        self.result_model = result_model
+      end
+
+      def parse(data)
+        (self.result_model ? self.result_model.parse(data) : self.model.parse(data))
+      end
+
+      def instantiate(data)
+        (self.result_model ? self.result_model.new(data) : self.model.new(data))
+      end
+
+      def instantiate_collection(parsed_data)
+        (self.result_model ? self.result_model.new_collection(parsed_data) : self.model.new_collection(parsed_data))
+      end
+
+      def copy(options = {})
+        self.class.new(self.model, self.transformations, self.result_model)
+      end
+
+      def add_transformation(type, parameter=nil)
+        self.transformations << {'transformation' => type, 'parameter' => parameter}
+      end
+
+      def filter(conditions={})
+        self.copy.tap do |query|
+          conditions.each do |key, value|
+            query.add_transformation("filter", {"field" => key, "value" => value})
+          end
+        end
+      end
+
+      def instance(id)
+        self.copy.tap do |query|
+          query.add_transformation("instance", id)
+        end
+      end
+
+      def context(association, model=nil)
+        self.copy.tap do |query|
+          query.result_model = (model ? model : association.to_s.singularize.camelize.constantize)
+          query.add_transformation("context", association.to_s)
+        end
+      end
+
+      def with(*fields)
+        self.copy.tap do |query|
+          fields.each do |field|
+            query.add_transformation("with", field.to_s)
+          end
+        end
+      end
+
+      def order(*fields)
+        self.copy.tap do |query|
+          fields.each do |field|
+            query.add_transformation("order", field)
+          end
+        end
+      end
+
+      def evaluate
+        self.do_query
+      end
+
+      def ids
+        query = self.copy
+        query.add_transformation("map_ids")
+        query.do_query
+      end
+
+      def count
+        query = self.copy
+        query.add_transformation("count")
+        query.do_query  
+      end
+
+      def do_query
+        transformer = Transformations::SequelTransformer.new(self.model.filter)
+        transformer.run(self.transformations)
+      end
+
+      def first(*args)
+        one("first", *args)
+      end
+
+      def last(*args)
+        one("last", *args)
+      end
+
+      def to_json(*args)
+        evaluate.to_json(*args)
+      end
+
+      def method_missing(method_name, *args, &block)
+        evaluate.send(method_name, *args, &block)
+      end
+
+    protected
+
+      def one(which, params = {})
+        query = self.copy
+        query.add_transformation(which)
+        query.do_query
+      end
+    end
+  end
+end

data/lib/query-interface-server/resource.rb

@@ -11,121 +11,14 @@ module QueryInterface
         end
       end
 
-      class UnknownTransformation < Exception; end
-      class InvalidContextException < Exception; end
-
       module InstanceMethods
-
-        attr_writer :context_type
-        attr_accessor :context
-
-        def validate_transformation(transformation)
-          methods = {
-            filter: {method: :filter_transformation, result: :dataset, accepts: :dataset},
-            with: {method: :with_transformation, result: :dataset, accepts: :dataset},
-            order: {method: :order_transformation, result: :dataset, accepts: :dataset},
-            instance: {method: :instance_transformation, result: :instance, accepts: :dataset},
-            context: {method: :context_transformation, result: :dataset, accepts: :instance},
-            map_ids: {method: :map_ids, result: :ids, accepts: :dataset},
-            paginate: {method: :paginate, result: :page, accepts: :dataset},
-            first: {method: :first, result: :instance, accepts: :dataset},
-            last: {method: :last, result: :instance, accepts: :dataset},
-            count: {method: :count, result: :count, accepts: :dataset}
-          }
-          argument_method = transformation['transformation'].to_sym
-          raise UnknownTransformation, "#{argument_method}" unless methods.has_key?(argument_method)
-          param = transformation['parameter']
-          description = methods[argument_method]
-          raise InvalidContextException, "expected: #{description[:accepts]}, got: #{self.context_type}" unless self.context_type == description[:accepts]
-          return [description[:method], param, description[:result]]
-        end
-
-        def context_type
-          @context_type ||= :dataset
-        end
-
-        def id_selector
-          primary_key = self.context.model.primary_key ? self.context.model.primary_key : :id
-          "#{self.context.model.table_name}__#{primary_key}".to_sym
-        end
-
-        def query_send(method_name, *args)
-          if respond_to?(method_name)
-            send(method_name, *args)
-          elsif self.context.respond_to?(method_name)
-            self.context.send(method_name, *args)
-          elsif block_given?
-            yield(*args)
-          else
-            raise Exception, "method #{method_name} not found"
-          end
-        end
-
-        def default_order
-          order_transformation(self.id_selector.to_s)
-        end
-
-        def filter_transformation(param)
-          self.query_send("filter_#{param['field']}", param['value'])
-        end
-
-        def with_transformation(param)
-          self.query_send("with_#{param}")
-        end
-
-        def order_transformation(param)
-          field = param
-          direction = :asc
-          if field.starts_with?('-')
-            field = field[1..-1]
-            direction = :desc
-          end
-          query_send("order_#{field}_#{direction}") do
-            self.context.order_append(Sequel.send(direction, field.to_sym))
-          end
-        end
-
-        def instance_transformation(param)
-          self.context.filter(self.id_selector => param).first
-        end
-
-        def context_transformation(param)
-          context = query_send("#{param}_dataset")
-          context.select_all(context.model.table_name)
-        end
-
-        def map_ids(param)
-          default_order.select(self.id_selector).map(&:id)
-        end
-
-        def count(param)
-          {count: self.context.count}
-        end
-
-        def paginate(param)
-          context = default_order
-          {total: context.count, objects: context.paginate(param['page'].to_i, param['per_page'].to_i)}
-        end
-
-        def first(param)
-          default_order.first
-        end
-
-        def last(param)
-          default_order.last
-        end
-
         def query
-          @context = query_model.filter.select_all(query_model.table_name)
+          transformer = Transformations::SequelTransformer.new(self.query_model.filter)
           transformations = params[:transformations] || []
           transformations = JSON.parse(transformations) unless transformations.is_a?(Array)
-          transformations.each do |transformation|
-            method, param, self.context_type = self.validate_transformation(transformation)
-            self.context = self.send(method, param)
-          end
-          self.context = self.default_order if self.context_type == :dataset
-          unless self.context.nil?
-            respond_with(self.context)
+          result = transformer.run(transformations)
+          unless result.nil?
+            respond_with(result)
           else
             render text: "", status: :not_found
           end

data/lib/query-interface-server/transformations.rb

@@ -0,0 +1,75 @@
+module QueryInterface
+  module Server
+    module Transformations
+
+      def self.included(base)    
+        base.extend(ClassMethods)
+        base.dataset_module do
+          def query_transformation(type, name, *args)
+            block = model.instance_variable_get(:@query_transformations)[type][name]
+            if block
+              self.instance_exec(*args, &block)
+            elsif type == :order and args.count == 1
+              self.order_append(Sequel.send(args[0], name.to_sym))
+            else
+              raise "No #{type} implementation for #{name}"
+            end
+          end
+        end
+        base.instance_variable_set(:@query_transformations, {
+          filter: {},
+          with: {},
+          order: {},
+        })
+      end
+
+      module ClassMethods
+        def query_transformations(&block)
+          scope = TransformationScope.new
+          scope.instance_eval(&block)
+
+          @query_transformations[:filter].merge!(scope.filters)
+          @query_transformations[:with].merge!(scope.withs)
+          @query_transformations[:order].merge!(scope.orders)
+        end
+
+        def query
+          return QueryInterface::Server::LazyQuery.new(self)
+        end
+
+      end
+
+      class TransformationScope
+        attr_accessor :filters, :withs, :orders
+
+        def initialize
+          self.filters = {}
+          self.withs = {}
+          self.orders = {}
+        end
+
+        def auto_filter(*names)
+          names.each do |name|
+            self.filters[name] = Proc.new do |param|
+              field = "#{model.table_name}__#{name}".to_sym
+              filter(field => param)
+            end
+          end
+        end
+
+        def filter(name, &block)
+          self.filters[name] = block
+        end
+
+        def with(name, &block)
+          self.withs[name] = block
+        end
+
+        def order(name, &block)
+          self.orders[name] = block
+        end
+      end
+
+    end
+  end
+end

data/lib/query-interface-server/transformations/sequel_transformer.rb

@@ -0,0 +1,111 @@
+module QueryInterface
+  module Server
+    module Transformations
+      class SequelTransformer
+        attr_accessor :model, :result
+
+        def initialize(dataset)
+          self.result = dataset.select_all(dataset.model.table_name)
+        end
+
+        def run(transformations)
+          transformations.each do |transformation|
+            method, param = self.validate(transformation)
+            self.result = self.send(method, param)
+          end
+          (self.result_type == :collection ? self.default_order : self.result)
+        end
+
+        def result_type
+          if self.result.is_a?(Sequel::Dataset)
+            :collection
+          elsif self.result.is_a?(Sequel::Model)
+            :instance
+          else
+            :atomic
+          end
+        end
+
+        def validate(transformation)
+          contraints = {
+            filter: :collection, with: :collection,order: :collection,
+            instance: :collection, context: :instance, map_ids: :collection,
+            paginate: :collection, first: :collection, last: :collection, count: :collection
+          }
+          method = transformation['transformation'].to_sym
+          raise UnknownTransformation, "#{method}" unless contraints.has_key?(method)
+          param = transformation['parameter']
+          unless self.result_type == contraints[method]
+            raise InvalidContextException, "expected: #{description[:accepts]}, got: #{self.result_type}"
+          end
+          return [method, param]
+        end
+
+        def table
+          self.result.model.table_name
+        end
+
+        def default_order
+          self.order(self.result.model.primary_key.to_s)
+        end
+
+        def id_selector
+          primary_key = self.result.model.primary_key ? self.result.model.primary_key : :id
+          "#{self.result.model.table_name}__#{primary_key}".to_sym
+        end
+
+        def filter(param)
+          self.result.query_transformation(:filter, param['field'].to_sym, param['value'])
+        end
+
+        def with(param)
+          self.result.query_transformation(:with, param.to_sym)
+        end
+
+        def order(param)
+          direction = :asc
+          if param.starts_with?('-')
+            param = param[1..-1]
+            direction = :desc
+          end
+          self.result.query_transformation(:order, param.to_sym, direction)
+        end
+
+        def instance(param)
+          self.result.filter(self.id_selector => param).first
+        end
+
+        def context(param)
+          name = "#{param}_dataset"
+          if self.result.respond_to?(name)
+            result = self.result.send(name)
+          else
+            raise Exception, "method #{name} not found"
+          end
+          result.select_all(result.model.table_name)
+        end
+
+        def map_ids(param)
+          self.default_order.select(self.id_selector).map(&:id)
+        end
+
+        def count(param)
+          {count: self.result.count}
+        end
+
+        def paginate(param)
+          context = self.default_order
+          {total: context.count, objects: context.paginate(param['page'].to_i, param['per_page'].to_i)}
+        end
+
+        def first(param)
+          self.default_order.first
+        end
+
+        def last(param)
+          self.default_order.last
+        end
+      end
+    end
+  end
+end

data/lib/query-interface-server/version.rb

@@ -1,7 +1,7 @@
 module QueryInterface
   module Server
 
-    VERSION = '0.1.3'
+    VERSION = '0.1.4'
 
   end
 end

data/spec/lib/resource_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe QueryInterface::Server::Resource, type: :controller do
+
+  class Foo
+  end
+
+  controller(ActionController::Base) do
+    respond_to :json
+    include QueryInterface::Server::Resource.for(Foo)
+  end
+
+  context 'self.for' do
+    it 'defines a query_model method' do
+      subject.query_model.should eq(Foo)
+    end
+
+    it 'includes the instance methods' do
+      subject.should respond_to(:query)
+    end
+  end
+
+  context "GET 'query'" do
+    before(:each) do
+      routes.draw { get "query" => "anonymous#query" }
+    end
+
+    it 'runs the transformations' do
+      dataset = double('dataset')
+      transformer = double('transformer')
+      result = double('result')
+      Foo.should_receive(:filter).and_return(dataset)
+      QueryInterface::Server::Transformations::SequelTransformer.should_receive(:new).with(dataset).and_return(transformer)
+      transformer.should_receive(:run).with([{'my' => 'transformations'}]).and_return(result)
+      get :query, transformations: [{'my' => 'transformations'}], format: :json
+      response.should be_success
+    end
+
+    it 'returns 404 when result is nil' do
+      dataset = double('dataset')
+      transformer = double('transformer')
+      Foo.should_receive(:filter).and_return(dataset)
+      QueryInterface::Server::Transformations::SequelTransformer.should_receive(:new).with(dataset).and_return(transformer)
+      transformer.should_receive(:run).with([{'my' => 'transformations'}]).and_return(nil)
+      get :query, transformations: [{'my' => 'transformations'}], format: :json
+      response.should be_not_found
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: query-interface-server
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Andreas Kopecky <andreas.kopecky@radarservices.com>
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-17 00:00:00.000000000 Z
+date: 2014-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -97,10 +97,13 @@ files:
 - README.md
 - Rakefile
 - lib/query-interface-server.rb
+- lib/query-interface-server/lazy_query.rb
 - lib/query-interface-server/resource.rb
+- lib/query-interface-server/transformations.rb
+- lib/query-interface-server/transformations/sequel_transformer.rb
 - lib/query-interface-server/version.rb
 - query-interface-server.gemspec
-- spec/lib/query_interface_spec.rb
+- spec/lib/resource_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/rs-dev/query-interface-server
 licenses:
@@ -122,9 +125,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.5
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Server for the radar query interface
 test_files: []
-has_rdoc: 

data/spec/lib/query_interface_spec.rb

@@ -1,312 +0,0 @@
-require "spec_helper"
-
-describe QueryInterface, type: :controller do
-  class Foo
-    def self.table_name
-      :foo_table
-    end
-  end
-
-  class Nested
-    def self.table_name
-      :nested_table
-    end
-  end
-
-
-  controller(ActionController::Base) do
-    respond_to :json
-    include QueryInterface::Server::Resource.for(Foo)
-  end
-  let(:foo){ double("Foo instance").as_null_object }
-  let(:foos){ double('foo instances', to_json: '{}', model: Foo) }
-
-  it "provides query_model as an instance method in the base class" do
-    controller.query_model.should == Foo
-  end
-
-  context "GET 'query'" do
-
-    context "transformations" do
-      it "only allows for a predefined list of transformations" do
-        expect {
-          controller.validate_transformation({'transformation' => 'bogus', 'parameter' => nil})
-        }.to raise_error("bogus")
-        controller.validate_transformation({'transformation' => 'with', 'parameter' => nil}).should eq([:with_transformation, nil, :dataset])
-      end
-
-      it "only allows transformations who accept the current content_type to run" do
-        controller.context_type = :instance
-        expect {
-          controller.validate_transformation({'transformation' => 'with', 'parameter' => 'y'})
-        }.to raise_error("expected: dataset, got: instance")
-      end
-
-      context "id selector" do
-        it "creates the id selector qualified from table name and primary key" do
-          controller.context = double('context', model: double('model', table_name: :table, primary_key: :id))
-          controller.id_selector.should == :table__id
-        end
-      end
-
-      context "context accessor" do
-        it "returns the existing context" do
-          context = double("context")
-          controller.instance_variable_set(:@context, context)
-          controller.context.should eq(context)
-        end
-
-      end
-
-    end
-
-    context "transformation methods" do
-      let(:context) {double("context")}
-
-      it "performs a filter transformation" do
-        controller.should_receive(:query_send).with('filter_a', 'b').and_return(context)
-        controller.filter_transformation({'field' => 'a', 'value' => 'b'}).should eq(context)
-      end
-
-      it "performs a with transformation" do
-        controller.should_receive(:query_send).with('with_x').and_return(context)
-        controller.with_transformation('x').should eq(context)
-      end
-
-      it "performs a instance transformation on an existing context" do
-        id_selector = :id_selector
-        controller.context = context
-        controller.should_receive(:id_selector).and_return(id_selector)
-        context.should_receive(:filter).with({id_selector => 42}).and_return(context)
-        context.should_receive(:first).and_return(context)
-        controller.instance_transformation(42).should eq(context)
-      end
-
-      it "performs a context transformation" do
-        controller.should_receive(:query_send).with('context_dataset').and_return(context)
-        context.should_receive(:model).and_return(double("model", table_name: :foo_table))
-        context.should_receive(:select_all).with(:foo_table).and_return(context)
-        controller.context_transformation('context').should eq(context)
-      end
-
-      context "order transformation" do
-        it "should call query_send with order_*_* for the supplied order field" do
-          ordered = double("ordered a")
-          controller.should_receive(:query_send).with("order_a_asc").and_return(ordered)
-          controller.order_transformation("a").should eq(ordered)
-        end
-
-        it "performs descending ordering if appropriate" do
-          ordered = double("ordered a")
-          controller.should_receive(:query_send).with("order_a_desc").and_return(ordered)
-          controller.order_transformation("-a").should eq(ordered)
-        end
-
-        it "performs a fallback sequel ordering operation when no concrete implementation is available" do
-          context = double("context")
-          ordered = double("ordered a")
-          controller.instance_variable_set(:@context, context)
-          context.should_receive(:order_append).with(Sequel.asc(:a)).and_return(ordered)
-          controller.order_transformation("a").should eq(ordered)
-        end
-
-        it "performs fallback for descending ordering" do
-          context = double("context")
-          ordered = double("ordered a")
-          controller.instance_variable_set(:@context, context)
-          context.should_receive(:order_append).with(Sequel.desc(:a)).and_return(ordered)
-          controller.order_transformation("-a").should eq(ordered)
-        end
-      end
-
-    end
-
-    context "query" do
-      before(:each) do
-        routes.draw { get "query" => "anonymous#query" }
-        Foo.stub(:filter).and_return(foos)
-        Foo.stub(:primary_key).and_return(:id)
-        controller.stub(:order_query)
-        foos.stub(:select_all).with(:foo_table).and_return(foos)
-      end
-
-
-      context "transformation processing" do
-        let(:filtered) { double('filtered').as_null_object }
-
-        it "calls the corresponding methods in any transformation" do
-          controller.should_receive(:filter_foo).with('bar').and_return(filtered)
-          get :query,
-            transformations: [
-                   {transformation: :filter, parameter: {field: :foo, value: 'bar'}},
-                 ], format: :json
-          assigns(:context).should == filtered
-          response.should be_ok
-        end
-
-        it "creates a new context if none is present" do
-          context = double("context")
-          controller.query_model.should_receive(:filter).and_return(foos)
-          controller.stub(:default_order).and_return(context)
-          foos.should_receive(:select_all).with(:foo_table).and_return(context)
-          get :query, transformations: [], format: :json
-          controller.context.should eq(context)
-          assigns(:context).should eq(context)
-          response.should be_ok
-        end
-
-        it "should respond with 404 when no result can be reached" do
-          context = double("context")
-          controller.query_model.should_receive(:filter).and_return(foos)
-          controller.stub(:default_order).and_return(nil)
-          foos.should_receive(:select_all).with(:foo_table).and_return(nil)
-          get :query, transformations: [], format: :json
-          controller.context.should eq(nil)
-          assigns(:context).should eq(nil)
-          response.should_not be_ok
-          response.status.should eq(404)
-        end
-      end
-
-
-      context "end points" do
-
-        it "should return a count of instances when an 'count' transformation is given" do
-          foos.should_receive(:count).and_return(42)
-          get :query,
-            transformations: [
-              {transformation: :count, parameter: nil}
-            ], format: :json
-          response.should be_ok
-          assigns(:context).should == {count: 42}
-        end
-
-        it "should return a hash with objects and total when a 'pagination' transformation is given" do
-          controller.should_receive(:default_order).and_return(foos)
-          foos.should_receive(:count).and_return(42)
-          foos.should_receive(:paginate).with(1, 10).and_return('paginated')
-          get :query,
-            transformations: [
-              {transformation: :paginate, parameter: {page: 1, per_page: 10}}
-            ], format: :json
-          response.should be_ok
-          assigns(:context).should == {objects: 'paginated', total: 42}
-        end
-
-        it "should return a single object when a 'first' transformation is given" do
-          controller.should_receive(:default_order).and_return(foos)
-          foos.should_receive(:first).and_return('first object')
-          get :query,
-            transformations: [
-              {transformation: :first, parameter: nil}
-            ], format: :json
-          assigns(:context).should == 'first object'
-        end
-
-        it "should return a single object when a 'last' transformation is given" do
-          controller.should_receive(:default_order).and_return(foos)
-          foos.should_receive(:last).and_return('last object')
-          get :query,
-            transformations: [
-              {transformation: :last, parameter: nil}
-            ], format: :json
-          assigns(:context).should == 'last object'
-        end
-
-        it "should return a list of ids when a 'map_ids' transformation is given" do
-          controller.should_receive(:default_order).and_return(foos)
-          foos.should_receive(:select).with(:foo_table__id).and_return([double("one", id: 1), double("two", id: 2)])
-          get :query,
-            transformations: [
-              {transformation: :map_ids, parameter: nil}
-            ], format: :json
-          assigns(:context).should == [1, 2]
-        end
-
-
-      end
-    end
-  end
-
-  context "instance calls" do
-    before(:each) do
-      routes.draw { get "query" => "anonymous#query" }
-      Foo.stub(:filter).and_return(foos)
-      Foo.stub(:table_name).and_return(:foo_table)
-      controller.stub(:order_query)
-    end
-
-    context "instance evaluation" do
-
-      it "queries for the single object supplied by instance" do
-        foos.should_receive(:select_all).with(:foo_table).and_return(foos)
-        id_selector = double("id selector")
-        controller.should_receive(:id_selector).and_return(id_selector)
-        foos.should_receive(:filter).with(id_selector => 99).and_return(foos)
-        foos.should_receive(:first).and_return(foo)
-        get :query, transformations:
-          [
-            {transformation: :instance, parameter:  99},
-          ], format: :json
-        response.should be_ok
-        assigns(:context).should eq(foo)
-      end
-
-      it "assigns an association dataset if a context is supplied" do
-        foos.should_receive(:select_all).with(:foo_table).and_return(foos)
-        id_selector = double("id selector")
-        nested = double("nested things", model: Nested)
-        controller.should_receive(:id_selector).and_return(id_selector)
-        foos.should_receive(:filter).with(id_selector => 99).and_return(foos)
-        foos.should_receive(:first).and_return(foo)
-        controller.should_receive(:query_send).with("nested_dataset").and_return(nested)
-        nested.should_receive(:select_all).with(:nested_table).and_return(nested)
-        controller.should_receive(:default_order).and_return(nested)
-        get :query, transformations:
-          [
-            {transformation: :instance, parameter:  99},
-            {transformation: :context, parameter: 'nested'},
-          ], format: :json
-        assigns(:context).should eq(nested)
-        response.should be_ok
-      end
-    end
-  end
-
-  context "query send" do
-    let(:send_result) {double("send result")}
-
-    before(:each) do
-      @context = double("context")
-      controller.instance_variable_set(:@context, @context)
-    end
-
-    it "should call the supplied method name on the controller if it responds to such a message" do
-      controller.should_receive(:respond_to?).with("method_name_foo").and_return(true)
-      controller.should_receive(:send).with("method_name_foo", "argument").and_return(send_result)
-      controller.query_send("method_name_foo", "argument").should eq(send_result)
-    end
-
-    it "should call the supplied method name on @context if avaiable and controller doesnt provide the method" do
-      controller.should_receive(:respond_to?).with("method_name_foo").and_return(false)
-      @context.should_receive(:respond_to?).with("method_name_foo").and_return(true)
-      @context.should_receive(:send).with("method_name_foo", "argument").and_return(send_result)
-      controller.query_send("method_name_foo", "argument").should eq(send_result)
-    end
-
-    it "should yield arguments to a supplied block if neither context nor controller provide the requested method" do
-      controller.should_receive(:respond_to?).with("method_name_foo").and_return(false)
-      @context.should_receive(:respond_to?).with("method_name_foo").and_return(false)
-      controller.query_send("method_name_foo", "argument") {|*args| args[0].should eq("argument")}
-    end
-
-    it "should raise an exception if non of the above can be done" do
-      controller.should_receive(:respond_to?).with("method_name_foo").and_return(false)
-      @context.should_receive(:respond_to?).with("method_name_foo").and_return(false)
-      expect {
-        controller.query_send("method_name_foo", "argument")
-      }.to raise_error(Exception, "method method_name_foo not found")
-    end
-  end
-
-end