diff --git a/spec/datagrid/column_names_attribute_spec.rb b/spec/datagrid/column_names_attribute_spec.rb
index 1cb04d9..4bfb005 100644
--- a/spec/datagrid/column_names_attribute_spec.rb
+++ b/spec/datagrid/column_names_attribute_spec.rb
@@ -9,7 +9,7 @@
 
   let(:report) do
     options = column_names_filter_options
-    test_report do
+    test_grid do
       scope { Entry }
       column_names_filter(**options)
       column(:id)
@@ -64,7 +64,7 @@
 
   context "when some columns are disabled" do
     subject do
-      test_report do
+      test_grid do
         scope { Entry }
         column(:id, mandatory: true)
         column(:name)
diff --git a/spec/datagrid/columns_spec.rb b/spec/datagrid/columns_spec.rb
index dbd47b3..57c6b26 100644
--- a/spec/datagrid/columns_spec.rb
+++ b/spec/datagrid/columns_spec.rb
@@ -26,7 +26,7 @@
     let(:date) { Date.new(2013, 8, 1) }
 
     it "should have data columns without html columns" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         column(:name)
         column(:action, html: true) do
@@ -38,15 +38,12 @@
     end
 
     it "allows a column argument" do
-      grid = test_report do
-        scope { Entry }
-        column(:name)
-      end
+      grid = test_grid_column(:name)
       expect(grid.data_columns(grid.column_by_name(:name)).map(&:name)).to eq([:name])
     end
 
     it "should build rows of data" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         column(:name)
         column(:action, html: true) do
@@ -56,7 +53,7 @@
       expect(grid.rows).to eq([["Star"]])
     end
     it "should generate header without html columns" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         column(:name)
         column(:action, html: true) do
@@ -103,7 +100,7 @@ class Report27 < Datagrid::Base
     end
 
     it "should return html_columns" do
-      report = test_report do
+      report = test_grid do
         scope { Entry }
         column(:id)
         column(:name, html: false)
@@ -112,7 +109,7 @@ class Report27 < Datagrid::Base
     end
 
     it "should return html_columns when column definition has 2 arguments" do
-      report = test_report(name: "Hello") do
+      report = test_grid(name: "Hello") do
         scope { Entry }
         filter(:name)
         column(:id)
@@ -132,10 +129,7 @@ class Report27 < Datagrid::Base
     end
 
     it "supports dynamic header" do
-      grid = test_report do
-        scope { Entry }
-        column(:id, header: proc { rand(10**9) })
-      end
+      grid = test_grid_column(:id, header: proc { rand(10**9) })
 
       expect(grid.header).to_not eq(grid.header)
     end
@@ -168,7 +162,7 @@ class Report27 < Datagrid::Base
   end
 
   it "should support columns with model and report arguments" do
-    report = test_report(category: "foo") do
+    report = test_grid(category: "foo") do
       scope { Entry.order(:category) }
       filter(:category) do |value|
         where("category LIKE '%#{value}%'")
@@ -199,7 +193,7 @@ class Report27 < Datagrid::Base
     expect(child.column_by_name(:group_id)).not_to be_nil
   end
   it "should support defining a query for a column" do
-    report = test_report do
+    report = test_grid do
       scope { Entry }
       filter(:name)
       column(:id)
@@ -210,7 +204,7 @@ class Report27 < Datagrid::Base
   end
 
   it "should support post formatting for column defined with query" do
-    report = test_report do
+    report = test_grid do
       scope { Group.joins(:entries).group("groups.id") }
       filter(:name)
       column(:entries_count, "count(entries.id)") do |model|
@@ -223,7 +217,7 @@ class Report27 < Datagrid::Base
     expect(report.rows).to eq([["(3)"]])
   end
   it "should support hidding columns through if and unless" do
-    report = test_report do
+    report = test_grid do
       scope { Entry }
       column(:id, if: :show?)
       column(:name, unless: proc { |grid| !grid.show? })
@@ -240,7 +234,7 @@ def show?
 
   it "raises when incorrect unless option is given" do
     expect do
-      test_report do
+      test_grid do
         column(:id, if: Object.new)
       end
     end.to raise_error(Datagrid::ConfigurationError)
@@ -248,7 +242,7 @@ def show?
 
   it "raises when :before and :after used together" do
     expect do
-      test_report do
+      test_grid do
         column(:id)
         column(:name, before: :id, after: :name)
       end
@@ -257,7 +251,7 @@ def show?
 
   describe ".column_names attributes" do
     let(:grid) do
-      test_report(column_names: %w[id name]) do
+      test_grid(column_names: %w[id name]) do
         scope { Entry }
         column(:id)
         column(:name)
@@ -285,12 +279,9 @@ def show?
 
   context "when grid has formatted column" do
     it "should output correct data" do
-      report = test_report do
-        scope { Entry }
-        column(:name) do |entry|
-          format(entry.name) do |value|
-            "<strong>#{value}</strong"
-          end
+      report = test_grid_column(:name) do |entry|
+        format(entry.name) do |value|
+          "<strong>#{value}</strong"
         end
       end
       Entry.create!(name: "Hello World")
@@ -300,7 +291,7 @@ def show?
 
   describe ".default_column_options" do
     it "should pass default options to each column definition" do
-      report = test_report do
+      report = test_grid do
         scope { Entry }
         self.default_column_options = { order: false }
         column(:id)
@@ -319,7 +310,7 @@ def show?
 
   describe "fetching data in batches" do
     it "should pass the batch size to the find_each method" do
-      report = test_report do
+      report = test_grid do
         scope { Entry }
         column :id
         self.batch_size = 25
@@ -332,7 +323,7 @@ def show?
       report.rows
     end
     it "should be able to disable batches" do
-      report = test_report do
+      report = test_grid do
         scope { Entry }
         column :id
         self.batch_size = 0
@@ -347,7 +338,7 @@ def show?
     end
 
     it "should support instance level batch size" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         column :id
         self.batch_size = 25
@@ -364,7 +355,7 @@ def show?
 
   describe ".data_row" do
     it "should give access to column values via an object" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         column(:id)
         column(:name) do
@@ -389,7 +380,7 @@ def show?
       group = Group.create!
       Entry.create(group: group)
       Entry.create(group: group)
-      grid = test_report do
+      grid = test_grid do
         scope { Group }
         column(:entries_count) do |g|
           g.entries.count
@@ -405,10 +396,7 @@ def show?
 
   describe "instance level column definition" do
     let(:modified_grid) do
-      grid = test_report do
-        scope { Entry }
-        column(:id)
-      end
+      grid = test_grid_column(:id)
       grid.column(:name)
       grid
     end
@@ -476,17 +464,11 @@ def show?
 
   describe ".data_value" do
     it "should return value" do
-      grid = test_report do
-        scope { Entry }
-        column(:name)
-      end
+      grid = test_grid_column(:name)
       expect(grid.data_value(:name, Entry.create!(name: "Hello"))).to eq("Hello")
     end
     it "should raise for disabled columns" do
-      grid = test_report do
-        scope { Entry }
-        column(:name, if: proc { false })
-      end
+      grid = test_grid_column(:name, if: proc { false })
       expect do
         grid.data_value(:name, Entry.create!(name: "Hello"))
       end.to raise_error(Datagrid::ColumnUnavailableError)
@@ -495,7 +477,7 @@ def show?
 
   describe "caching" do
     it "should work when enabled in class" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         self.cached = true
         column(:random1) { rand(10**9) }
@@ -536,7 +518,7 @@ def capitalized_name
     end
 
     it "delegates column values to decorator" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         decorate { |model| EntryDecorator.new(model) }
         column(:capitalized_name)
@@ -552,7 +534,7 @@ def capitalized_name
     end
 
     it "allows class decorator" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         decorate { EntryDecorator }
         column(:capitalized_name)
@@ -563,39 +545,27 @@ def capitalized_name
 
   describe "column scope" do
     it "appends preload as non block" do
-      grid = test_report do
-        scope { Entry }
-        column(:id, preload: [:group])
-      end
+      grid = test_grid_column(:id, preload: [:group])
       expect(grid.assets.preload_values).to_not be_blank
     end
 
     it "appends preload with no args" do
-      grid = test_report do
-        scope { Entry }
-        column(:id, preload: -> { order(:id) })
-      end
+      grid = test_grid_column(:id, preload: -> { order(:id) })
       expect(grid.assets.order_values).to_not be_blank
     end
 
     it "appends preload with arg" do
-      grid = test_report do
-        scope { Entry }
-        column(:id, preload: ->(a) { a.order(:id) })
-      end
+      grid = test_grid_column(:id, preload: ->(a) { a.order(:id) })
       expect(grid.assets.order_values).to_not be_blank
     end
 
     it "appends preload as true value" do
-      grid = test_report do
-        scope { Entry }
-        column(:group, preload: true)
-      end
+      grid = test_grid_column(:group, preload: true)
       expect(grid.assets.preload_values).to eq([:group])
     end
 
     it "doesn't append preload when column is invisible" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         column(:id1, preload: ->(a) { a.order(:id) })
         column(:id2, preload: ->(a) { a.order(:id) }, if: ->(_a) { false })
diff --git a/spec/datagrid/core_spec.rb b/spec/datagrid/core_spec.rb
index f7cea42..35a03a4 100644
--- a/spec/datagrid/core_spec.rb
+++ b/spec/datagrid/core_spec.rb
@@ -6,15 +6,13 @@
 describe Datagrid::Core do
   describe "#original_scope" do
     it "does not wrap instance scope" do
-      grid = test_report do
-        scope { Entry }
-      end
+      grid = test_grid
 
       expect(grid.original_scope).to eq(Entry)
     end
 
     it "does not wrap class scope" do
-      klass = test_report_class do
+      klass = test_grid_class do
         scope { Entry }
       end
 
@@ -34,9 +32,7 @@ class ScopeTestReport < Datagrid::Base
 
     describe "#scope" do
       it "wraps scope" do
-        grid = test_report do
-          scope { Entry }
-        end
+        grid = test_grid
         expect(grid.scope).to be_kind_of(ActiveRecord::Relation)
       end
 
@@ -137,7 +133,7 @@ class EqualTest < Datagrid::Base
 
   describe "dynamic helper" do
     it "should work" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         column(:id)
         dynamic do
@@ -154,7 +150,7 @@ class EqualTest < Datagrid::Base
     end
 
     it "has access to attributes" do
-      grid = test_report(attribute_name: "value") do
+      grid = test_grid(attribute_name: "value") do
         scope { Entry }
         datagrid_attribute :attribute_name
         dynamic do
@@ -167,7 +163,7 @@ class EqualTest < Datagrid::Base
     end
 
     it "applies before instance scope" do
-      klass = test_report_class do
+      klass = test_grid_class do
         scope { Entry }
         dynamic do
           scope do |s|
@@ -184,7 +180,7 @@ class EqualTest < Datagrid::Base
     end
 
     it "has access to grid attributes within scope" do
-      grid = test_report(name: "one") do
+      grid = test_grid(name: "one") do
         scope { Entry }
         dynamic do
           scope do |s|
@@ -206,7 +202,7 @@ class EqualTest < Datagrid::Base
     end
 
     it "permites all attributes by default" do
-      grid = test_report(params) do
+      grid = test_grid(params) do
         scope { Entry }
         filter(:name)
       end
@@ -216,7 +212,7 @@ class EqualTest < Datagrid::Base
 
     it "doesn't permit attributes when forbidden_attributes_protection is set" do
       expect do
-        test_report(params) do
+        test_grid(params) do
           scope { Entry }
           self.forbidden_attributes_protection = true
           filter(:name)
@@ -226,7 +222,7 @@ class EqualTest < Datagrid::Base
 
     it "permits attributes when forbidden_attributes_protection is set and attributes are permitted" do
       expect do
-        test_report(params.permit!) do
+        test_grid(params.permit!) do
           scope { Entry }
           self.forbidden_attributes_protection = true
           filter(:name)
@@ -235,7 +231,7 @@ class EqualTest < Datagrid::Base
     end
 
     it "supports hash attribute assignment" do
-      grid = test_report(
+      grid = test_grid(
         ActionController::Parameters.new(group_id: { from: 1, to: 2 }),
       ) do
         scope { Entry }
@@ -247,7 +243,7 @@ class EqualTest < Datagrid::Base
 
   describe ".query_param" do
     it "works" do
-      grid = test_report(name: "value") do
+      grid = test_grid(name: "value") do
         scope { Entry }
         filter(:name)
         def param_name
diff --git a/spec/datagrid/drivers/active_record_spec.rb b/spec/datagrid/drivers/active_record_spec.rb
index 872cb49..d8a802c 100644
--- a/spec/datagrid/drivers/active_record_spec.rb
+++ b/spec/datagrid/drivers/active_record_spec.rb
@@ -18,15 +18,16 @@
   end
 
   it "should support append_column_queries" do
-    scope = subject.append_column_queries(Entry.where({}),
-      [Datagrid::Columns::Column.new(test_report_class, :sum_group_id,
-        "sum(entries.group_id)",)],)
+    scope = subject.append_column_queries(
+      Entry.where({}),
+      [Datagrid::Columns::Column.new(test_grid_class, :sum_group_id, "sum(entries.group_id)")],
+    )
     expect(scope.to_sql.strip).to eq('SELECT "entries".*, sum(entries.group_id) AS sum_group_id FROM "entries"')
   end
 
   describe "Arel" do
     subject do
-      test_report(order: :test, descending: true) do
+      test_grid(order: :test, descending: true) do
         scope { Entry }
         column(:test, order: Entry.arel_table[:group_id].count)
       end.assets
@@ -39,7 +40,7 @@
 
   describe "where by timestamp" do
     subject do
-      test_report(created_at: 10.days.ago..5.days.ago) do
+      test_grid(created_at: 10.days.ago..5.days.ago) do
         scope { Entry }
 
         filter(:created_at, :date, range: true) do |value, scope, _grid|
@@ -67,7 +68,7 @@
 
   describe "batches usage" do
     it "should be incompatible with scope with limit" do
-      report = test_report do
+      report = test_grid do
         scope { Entry.limit(5) }
         self.batch_size = 20
         column(:id)
diff --git a/spec/datagrid/drivers/array_spec.rb b/spec/datagrid/drivers/array_spec.rb
index daf3663..50fb0ad 100644
--- a/spec/datagrid/drivers/array_spec.rb
+++ b/spec/datagrid/drivers/array_spec.rb
@@ -90,7 +90,7 @@ class ArrayGrid < Datagrid::Base
 
   describe "when using enumerator scope" do
     it "should work fine" do
-      grid = test_report(to_enum: true) do
+      grid = test_grid(to_enum: true) do
         scope { [] }
         filter(:to_enum, :boolean) do |_, scope|
           scope.to_enum
diff --git a/spec/datagrid/drivers/mongo_mapper_spec.rb b/spec/datagrid/drivers/mongo_mapper_spec.rb
index 750f02d..b1fa72e 100644
--- a/spec/datagrid/drivers/mongo_mapper_spec.rb
+++ b/spec/datagrid/drivers/mongo_mapper_spec.rb
@@ -86,7 +86,7 @@
       end
       it "should not provide default order for non declared fields" do
         expect do
-          test_report(order: :test) do
+          test_grid(order: :test) do
             scope { MongoMapperEntry }
             column(:test)
           end.assets
diff --git a/spec/datagrid/drivers/mongoid_spec.rb b/spec/datagrid/drivers/mongoid_spec.rb
index d68958d..5e616ce 100644
--- a/spec/datagrid/drivers/mongoid_spec.rb
+++ b/spec/datagrid/drivers/mongoid_spec.rb
@@ -85,7 +85,7 @@
 
     it "should not provide default order for non declared fields" do
       expect do
-        test_report(order: :test) do
+        test_grid(order: :test) do
           scope { MongoidEntry }
           column(:test)
         end.assets
@@ -93,7 +93,7 @@
     end
 
     it "should support batch_size" do
-      report = test_report do
+      report = test_grid do
         scope { MongoidEntry }
         self.batch_size = 1
         column(:name)
diff --git a/spec/datagrid/drivers/sequel_spec.rb b/spec/datagrid/drivers/sequel_spec.rb
index 93c0636..225491f 100644
--- a/spec/datagrid/drivers/sequel_spec.rb
+++ b/spec/datagrid/drivers/sequel_spec.rb
@@ -96,7 +96,7 @@ class PaginationTest < Datagrid::Base
 
     it "should provide default order for non declared fields" do
       expect do
-        test_report(order: :test) do
+        test_grid(order: :test) do
           scope { SequelEntry }
           column(:test) do
             "test"
@@ -106,7 +106,7 @@ class PaginationTest < Datagrid::Base
     end
 
     it "should support batch_size" do
-      report = test_report do
+      report = test_grid do
         scope { SequelEntry }
         self.batch_size = 1
         column(:name)
diff --git a/spec/datagrid/filters/base_filter_spec.rb b/spec/datagrid/filters/base_filter_spec.rb
index 9f86ec2..cb3c84d 100644
--- a/spec/datagrid/filters/base_filter_spec.rb
+++ b/spec/datagrid/filters/base_filter_spec.rb
@@ -4,7 +4,7 @@
 
 describe Datagrid::Filters::BaseFilter do
   it "should support default option as block" do
-    report = test_report do
+    report = test_grid do
       scope { Entry }
       filter(:name, :string, default: :name_default)
       def name_default
@@ -18,7 +18,7 @@ def name_default
 
   describe "#default_scope?" do
     it "identifies filters without custom block" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         filter(:id, :integer)
         filter(:group_id, :integer) do |value, _scope|
diff --git a/spec/datagrid/filters/boolean_filter_spec.rb b/spec/datagrid/filters/boolean_filter_spec.rb
index 4b10491..3211723 100644
--- a/spec/datagrid/filters/boolean_filter_spec.rb
+++ b/spec/datagrid/filters/boolean_filter_spec.rb
@@ -4,10 +4,7 @@
 
 describe Datagrid::Filters::BooleanFilter do
   it "applies default filtering" do
-    grid = test_report do
-      scope { Entry }
-      filter(:disabled, :boolean)
-    end
+    grid = test_grid_filter(:disabled, :boolean)
 
     disabled_entry = Entry.create!(disabled: true)
     enabled_entry = Entry.create!(disabled: false)
@@ -26,10 +23,7 @@
   end
 
   it "type casts any value to boolean" do
-    grid = test_report do
-      scope { Entry }
-      filter(:disabled, :boolean)
-    end
+    grid = test_grid_filter(:disabled, :boolean)
 
     grid.disabled = true
     expect(grid.disabled).to eq(true)
diff --git a/spec/datagrid/filters/date_filter_spec.rb b/spec/datagrid/filters/date_filter_spec.rb
index 15e3fb3..2f83b75 100644
--- a/spec/datagrid/filters/date_filter_spec.rb
+++ b/spec/datagrid/filters/date_filter_spec.rb
@@ -10,10 +10,8 @@
     e3 = Entry.create!(created_at: 3.days.ago)
     e4 = Entry.create!(created_at: 1.day.ago)
 
-    report = test_report(created_at: 5.day.ago..3.days.ago) do
-      scope { Entry }
-      filter(:created_at, :date, range: true)
-    end
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = 5.day.ago..3.days.ago
 
     expect(report.created_at).to eq(5.days.ago.to_date..3.days.ago.to_date)
     expect(report.assets).not_to include(e1)
@@ -24,7 +22,7 @@
 
   it "raises when range assigned to non-range filter" do
     expect do
-      test_report(created_at: 5.day.ago..3.days.ago) do
+      test_grid(created_at: 5.day.ago..3.days.ago) do
         scope { Entry }
         filter(:created_at, :date)
       end
@@ -34,10 +32,10 @@
   it "endless date range argument" do
     e1 = Entry.create!(created_at: 7.days.ago)
     e2 = Entry.create!(created_at: 4.days.ago)
-    report = test_report(created_at: 5.days.ago..) do
-      scope { Entry }
-      filter(:created_at, :date, range: true)
-    end
+
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = (5.days.ago..)
+
     expect(report.assets).not_to include(e1)
     expect(report.assets).to include(e2)
     report.created_at = ..5.days.ago
@@ -46,10 +44,7 @@
   end
 
   it "supports hash argument for range filter" do
-    report = test_report do
-      scope { Entry }
-      filter(:created_at, :date, range: true)
-    end
+    report = test_grid_filter(:created_at, :date, range: true)
     from = 5.days.ago
     to = 3.days.ago
     report.created_at = { from: from, to: to }
@@ -79,7 +74,7 @@
       describe "date to timestamp conversion" do
         let(:klass) { klass }
         subject do
-          test_report(created_at: _created_at) do
+          test_grid(created_at: _created_at) do
             scope { klass }
             filter(:created_at, :date, range: true)
           end.assets.to_a
@@ -114,10 +109,10 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: 7.days.ago)
     e2 = Entry.create!(created_at: 4.days.ago)
     e3 = Entry.create!(created_at: 1.day.ago)
-    report = test_report(created_at: [5.day.ago.to_date.to_s, 3.days.ago.to_date.to_s]) do
-      scope { Entry }
-      filter(:created_at, :date, range: true)
-    end
+
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = [5.day.ago.to_date.to_s, 3.days.ago.to_date.to_s]
+
     expect(report.assets).not_to include(e1)
     expect(report.assets).to include(e2)
     expect(report.assets).not_to include(e3)
@@ -127,10 +122,9 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: 7.days.ago)
     e2 = Entry.create!(created_at: 4.days.ago)
     e3 = Entry.create!(created_at: 1.day.ago)
-    report = test_report(created_at: [5.day.ago.to_date.to_s, nil]) do
-      scope { Entry }
-      filter(:created_at, :date, range: true)
-    end
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = [5.day.ago.to_date.to_s, nil]
+
     expect(report.assets).not_to include(e1)
     expect(report.assets).to include(e2)
     expect(report.assets).to include(e3)
@@ -140,10 +134,9 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: 7.days.ago)
     e2 = Entry.create!(created_at: 4.days.ago)
     e3 = Entry.create!(created_at: 1.day.ago)
-    report = test_report(created_at: [nil, 3.days.ago.to_date.to_s]) do
-      scope { Entry }
-      filter(:created_at, :date, range: true)
-    end
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = [nil, 3.days.ago.to_date.to_s]
+
     expect(report.assets).to include(e1)
     expect(report.assets).to include(e2)
     expect(report.assets).not_to include(e3)
@@ -153,10 +146,9 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: 7.days.ago)
     e2 = Entry.create!(created_at: 4.days.ago)
     e3 = Entry.create!(created_at: 1.day.ago)
-    report = test_report(created_at: (4.days.ago.to_date..4.days.ago.to_date)) do
-      scope { Entry }
-      filter(:created_at, :date, range: true)
-    end
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = (4.days.ago.to_date..4.days.ago.to_date)
+
     expect(report.assets).not_to include(e1)
     expect(report.assets).to include(e2)
     expect(report.assets).not_to include(e3)
@@ -167,10 +159,10 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: 7.days.ago)
     e2 = Entry.create!(created_at: 4.days.ago)
     e3 = Entry.create!(created_at: 1.day.ago)
-    report = test_report(created_at: range) do
-      scope { Entry }
-      filter(:created_at, :date, range: true)
-    end
+
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = range
+
     expect(report.created_at).to eq(range.last.to_date..range.first.to_date)
     expect(report.assets).to include(e1)
     expect(report.assets).to include(e2)
@@ -180,12 +172,12 @@ def entry_dated(date)
   it "should support block" do
     date = Date.new(2018, 0o1, 0o7)
     time = Time.utc(2018, 0o1, 0o7, 2, 2)
-    report = test_report(created_at: date) do
-      scope { Entry }
-      filter(:created_at, :date, range: true) do |value|
-        where(created_at: value)
-      end
+
+    report = test_grid_filter(:created_at, :date, range: true) do |value|
+      where(created_at: value)
     end
+    report.created_at = date
+
     expect(report.assets).not_to include(Entry.create!(created_at: time - 1.day))
     expect(report.assets).to include(Entry.create!(created_at: time))
   end
@@ -198,61 +190,45 @@ def entry_dated(date)
     end
 
     it "should have configurable date format" do
-      report = test_report(created_at: "10/01/2013") do
-        scope  { Entry }
-        filter(:created_at, :date)
-      end
+      report = test_grid_filter(:created_at, :date)
+      report.created_at = "10/01/2013"
+
       expect(report.created_at).to eq(Date.new(2013, 10, 0o1))
     end
 
     it "should support default explicit date" do
-      report = test_report(created_at: Date.parse("2013-10-01")) do
-        scope  { Entry }
-        filter(:created_at, :date)
-      end
+      report = test_grid_filter(:created_at, :date)
+      report.created_at = Date.parse("2013-10-01")
+
       expect(report.created_at).to eq(Date.new(2013, 10, 0o1))
     end
   end
 
   it "should automatically reverse if first more than last" do
-    report = test_report(created_at: %w[2013-01-01 2012-01-01]) do
-      scope  { Entry }
-      filter(:created_at, :date, range: true)
-    end
-    expect(report.created_at).to eq(Date.new(2012, 0o1, 0o1)..Date.new(2013, 0o1, 0o1))
-  end
-  it "should automatically reverse if first more than last" do
-    report = test_report(created_at: %w[2013-01-01 2012-01-01]) do
-      scope  { Entry }
-      filter(:created_at, :date, range: true)
-    end
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = %w[2013-01-01 2012-01-01]
+
     expect(report.created_at).to eq(Date.new(2012, 0o1, 0o1)..Date.new(2013, 0o1, 0o1))
   end
 
   it "should nullify blank range" do
-    report = test_report(created_at: [nil, nil]) do
-      scope  { Entry }
-      filter(:created_at, :date, range: true)
-    end
+    report = test_grid_filter(:created_at, :date, range: true)
+    report.created_at = [nil ,nil]
 
     expect(report.created_at).to eq(nil)
   end
 
   it "should properly format date in filter_value_as_string" do
     with_date_format do
-      report = test_report(created_at: "2012-01-02") do
-        scope  { Entry }
-        filter(:created_at, :date)
-      end
+      report = test_grid_filter(:created_at, :date)
+      report.created_at = "2012-01-02"
+
       expect(report.filter_value_as_string(:created_at)).to eq("01/02/2012")
     end
   end
 
   it "deserializes range" do
-    report = test_report do
-      scope  { Entry }
-      filter(:created_at, :date, range: true)
-    end
+    report = test_grid_filter(:created_at, :date, range: true)
 
     value = Date.new(2012, 1, 1)..Date.new(2012, 1, 2)
     report.created_at = value.as_json
@@ -260,10 +236,9 @@ def entry_dated(date)
   end
 
   it "supports search by timestamp column" do
-    report = test_report(created_at: Date.today) do
-      scope { Entry }
-      filter(:created_at, :date)
-    end
+    report = test_grid_filter(:created_at, :date)
+    report.created_at = Date.today
+
     e1 = Entry.create!(created_at: Date.yesterday + 23.hours)
     e2 = Entry.create!(created_at: Date.today.to_time)
     e3 = Entry.create!(created_at: Date.today + 12.hours)
diff --git a/spec/datagrid/filters/date_time_filter_spec.rb b/spec/datagrid/filters/date_time_filter_spec.rb
index c3d99c9..9b6f807 100644
--- a/spec/datagrid/filters/date_time_filter_spec.rb
+++ b/spec/datagrid/filters/date_time_filter_spec.rb
@@ -9,7 +9,7 @@
         let(:klass) { klass }
 
         let(:grid) do
-          test_report(created_at: _created_at) do
+          test_grid(created_at: _created_at) do
             scope { klass }
             filter(:created_at, :datetime, range: true)
           end
@@ -64,10 +64,10 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: Time.new(2013, 1, 1, 1, 0))
     e2 = Entry.create!(created_at: Time.new(2013, 1, 1, 2, 0))
     e3 = Entry.create!(created_at: Time.new(2013, 1, 1, 3, 0))
-    report = test_report(created_at: [Time.new(2013, 1, 1, 1, 30).to_s, Time.new(2013, 1, 1, 2, 30).to_s]) do
-      scope { Entry }
-      filter(:created_at, :datetime, range: true)
-    end
+
+    report = test_grid_filter(:created_at, :datetime, range: true)
+    report.created_at = [Time.new(2013, 1, 1, 1, 30).to_s, Time.new(2013, 1, 1, 2, 30).to_s]
+
     expect(report.assets).not_to include(e1)
     expect(report.assets).to include(e2)
     expect(report.assets).not_to include(e3)
@@ -77,10 +77,10 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: Time.new(2013, 1, 1, 1, 0))
     e2 = Entry.create!(created_at: Time.new(2013, 1, 1, 2, 0))
     e3 = Entry.create!(created_at: Time.new(2013, 1, 1, 3, 0))
-    report = test_report(created_at: [Time.new(2013, 1, 1, 1, 30).to_s, nil]) do
-      scope { Entry }
-      filter(:created_at, :datetime, range: true)
-    end
+
+    report = test_grid_filter(:created_at, :datetime, range: true)
+    report.created_at = [Time.new(2013, 1, 1, 1, 30).to_s, nil]
+
     expect(report.assets).not_to include(e1)
     expect(report.assets).to include(e2)
     expect(report.assets).to include(e3)
@@ -90,10 +90,10 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: Time.new(2013, 1, 1, 1, 0))
     e2 = Entry.create!(created_at: Time.new(2013, 1, 1, 2, 0))
     e3 = Entry.create!(created_at: Time.new(2013, 1, 1, 3, 0))
-    report = test_report(created_at: [nil, Time.new(2013, 1, 1, 2, 30).to_s]) do
-      scope { Entry }
-      filter(:created_at, :datetime, range: true)
-    end
+
+    report = test_grid_filter(:created_at, :datetime, range: true)
+    report.created_at = [nil, Time.new(2013, 1, 1, 2, 30).to_s]
+
     expect(report.assets).to include(e1)
     expect(report.assets).to include(e2)
     expect(report.assets).not_to include(e3)
@@ -103,10 +103,10 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: Time.new(2013, 1, 1, 1, 0))
     e2 = Entry.create!(created_at: Time.new(2013, 1, 1, 2, 0))
     e3 = Entry.create!(created_at: Time.new(2013, 1, 1, 3, 0))
-    report = test_report(created_at: Time.new(2013, 1, 1, 2, 0)..Time.new(2013, 1, 1, 2, 0)) do
-      scope { Entry }
-      filter(:created_at, :datetime, range: true)
-    end
+
+    report = test_grid_filter(:created_at, :datetime, range: true)
+    report.created_at = Time.new(2013, 1, 1, 2, 0)..Time.new(2013, 1, 1, 2, 0)
+
     expect(report.assets).not_to include(e1)
     expect(report.assets).to include(e2)
     expect(report.assets).not_to include(e3)
@@ -117,10 +117,10 @@ def entry_dated(date)
     e1 = Entry.create!(created_at: Time.new(2013, 1, 1, 1, 0))
     e2 = Entry.create!(created_at: Time.new(2013, 1, 1, 2, 0))
     e3 = Entry.create!(created_at: Time.new(2013, 1, 1, 3, 0))
-    report = test_report(created_at: range) do
-      scope { Entry }
-      filter(:created_at, :datetime, range: true)
-    end
+
+    report = test_grid_filter(:created_at, :datetime, range: true)
+    report.created_at = range
+
     expect(report.created_at).to eq(range.last..range.first)
     expect(report.assets).to include(e1)
     expect(report.assets).to include(e2)
@@ -128,12 +128,11 @@ def entry_dated(date)
   end
 
   it "should support block" do
-    report = test_report(created_at: Time.now..) do
-      scope { Entry }
-      filter(:created_at, :datetime, range: true) do |value|
-        where(created_at: value)
-      end
+    report = test_grid_filter(:created_at, :datetime) do |value|
+      where("created_at >= ?", value)
     end
+    report.created_at = Time.now
+
     expect(report.assets).not_to include(Entry.create!(created_at: 1.day.ago))
     expect(report.assets).to include(Entry.create!(created_at: Time.now + 1.day))
   end
@@ -146,37 +145,30 @@ def entry_dated(date)
     end
 
     it "should have configurable datetime format" do
-      report = test_report(created_at: "10/01/2013 01:00") do
-        scope  { Entry }
-        filter(:created_at, :datetime)
-      end
+      report = test_grid_filter(:created_at, :datetime)
+      report.created_at = "10/01/2013 01:00"
       expect(report.created_at).to eq(Time.new(2013, 10, 0o1, 1, 0))
     end
 
     it "should support default explicit datetime" do
-      report = test_report(created_at: Time.parse("2013-10-01 01:00")) do
-        scope  { Entry }
-        filter(:created_at, :datetime)
-      end
+      report = test_grid_filter(:created_at, :datetime)
+      report.created_at = Time.parse("2013-10-01 01:00")
+
       expect(report.created_at).to eq(Time.new(2013, 10, 0o1, 1, 0))
     end
   end
 
   it "should automatically reverse Array if first more than last" do
-    report = test_report(created_at: ["2013-01-01 01:00", "2012-01-01 01:00"]) do
-      scope  { Entry }
-      filter(:created_at, :datetime, range: true)
-    end
+    report = test_grid_filter(:created_at, :datetime, range: true)
+    report.created_at = ["2013-01-01 01:00", "2012-01-01 01:00"]
+
     expect(report.created_at).to eq(Time.new(2012, 0o1, 0o1, 1, 0)..Time.new(2013, 0o1, 0o1, 1, 0))
   end
 
   it "supports serialized range value" do
     from = Time.parse("2013-01-01 01:00")
     to = Time.parse("2013-01-02 02:00")
-    report  = test_report do
-      scope { Entry }
-      filter(:created_at, :datetime, range: true)
-    end
+    report  = test_grid_filter(:created_at, :datetime, range: true)
 
     report.created_at = (from..to).as_json
     expect(report.created_at).to eq(from..to)
diff --git a/spec/datagrid/filters/dynamic_filter_spec.rb b/spec/datagrid/filters/dynamic_filter_spec.rb
index c658ff8..b84f2fc 100644
--- a/spec/datagrid/filters/dynamic_filter_spec.rb
+++ b/spec/datagrid/filters/dynamic_filter_spec.rb
@@ -4,10 +4,7 @@
 
 describe Datagrid::Filters::DynamicFilter do
   let(:report) do
-    test_report do
-      scope { Entry }
-      filter(:condition, :dynamic)
-    end
+    test_grid_filter(:condition, :dynamic)
   end
 
   it "should support = operation" do
@@ -125,17 +122,14 @@
   end
 
   it "should support allow_nil and allow_blank options" do
-    grid = test_report do
-      scope { Entry }
-      filter(
-        :condition, :dynamic, allow_nil: true, allow_blank: true,
-        operations: [">=", "<="],
-      ) do |(field, operation, value), scope|
-        if value.blank?
-          scope.where(disabled: false)
-        else
-          scope.where("#{field} #{operation} ?", value)
-        end
+    grid = test_grid_filter(
+      :condition, :dynamic, allow_nil: true, allow_blank: true,
+      operations: [">=", "<="]
+    ) do |(field, operation, value), scope|
+      if value.blank?
+        scope.where(disabled: false)
+      else
+        scope.where("#{field} #{operation} ?", value)
       end
     end
 
@@ -150,7 +144,7 @@
   it "should support custom operations" do
     entry = Entry.create!(name: "hello")
 
-    grid = test_report do
+    grid = test_grid do
       scope { Entry }
       filter(
         :condition, :dynamic, operations: ["=", "!="],
diff --git a/spec/datagrid/filters/enum_filter_spec.rb b/spec/datagrid/filters/enum_filter_spec.rb
index bc61a96..c8d44d0 100644
--- a/spec/datagrid/filters/enum_filter_spec.rb
+++ b/spec/datagrid/filters/enum_filter_spec.rb
@@ -4,23 +4,18 @@
 
 describe Datagrid::Filters::EnumFilter do
   it "should support select option" do
-    report = test_report do
-      scope { Entry }
-      filter(:group_id, :enum, select: [1, 2])
-    end
+    report = test_grid_filter(:group_id, :enum, select: [1, 2])
     expect(report.filter_by_name(:group_id).select(report)).to eq([1, 2])
   end
 
   it "should support select option as proc" do
-    grid = test_report do
-      scope { Entry }
-      filter(:group_id, :enum, select: proc { [1, 2] })
-    end
+    grid = test_grid_filter(:group_id, :enum, select: proc { [1, 2] })
+
     expect(grid.filter_by_name(:group_id).select(grid)).to eq([1, 2])
   end
 
   it "should support select option as proc with instace input" do
-    klass = test_report do
+    klass = test_grid do
       scope { Entry }
       filter(:group_id, :enum, select: proc(&:object_id))
     end.class
@@ -36,7 +31,7 @@ class ReportWithLazySelect < Datagrid::Base
   end
 
   it "should support select given as symbol" do
-    report = test_report do
+    report = test_grid do
       scope { Entry }
       filter(:group_id, :enum, select: :selectable_group_ids)
       def selectable_group_ids
diff --git a/spec/datagrid/filters/extended_boolean_filter_spec.rb b/spec/datagrid/filters/extended_boolean_filter_spec.rb
index f70f6da..01daca5 100644
--- a/spec/datagrid/filters/extended_boolean_filter_spec.rb
+++ b/spec/datagrid/filters/extended_boolean_filter_spec.rb
@@ -4,18 +4,12 @@
 
 describe Datagrid::Filters::ExtendedBooleanFilter do
   it "should support select option" do
-    grid = test_report do
-      scope { Entry }
-      filter(:disabled, :xboolean)
-    end
+    grid = test_grid_filter(:disabled, :xboolean)
     expect(grid.filter_by_name(:disabled).select(grid)).to eq([%w[Yes YES], %w[No NO]])
   end
 
   it "should generate pass boolean value to filter block" do
-    grid = test_report do
-      scope { Entry }
-      filter(:disabled, :xboolean)
-    end
+    grid = test_grid_filter(:disabled, :xboolean)
 
     disabled_entry = Entry.create!(disabled: true)
     enabled_entry = Entry.create!(disabled: false)
@@ -34,10 +28,8 @@
   end
 
   it "should normalize true/false as YES/NO" do
-    grid = test_report do
-      scope { Entry }
-      filter(:disabled, :xboolean)
-    end
+    grid = test_grid_filter(:disabled, :xboolean)
+
     grid.disabled = true
     expect(grid.disabled).to eq("YES")
     grid.disabled = false
diff --git a/spec/datagrid/filters/float_filter_spec.rb b/spec/datagrid/filters/float_filter_spec.rb
index e45066f..92e699d 100644
--- a/spec/datagrid/filters/float_filter_spec.rb
+++ b/spec/datagrid/filters/float_filter_spec.rb
@@ -6,7 +6,7 @@
   it "should support float values" do
     g1 = Group.create!(rating: 1.5)
     g2 = Group.create!(rating: 1.6)
-    report = test_report(rating: 1.5) do
+    report = test_grid(rating: 1.5) do
       scope { Group }
       filter(:rating, :float)
     end
diff --git a/spec/datagrid/filters/integer_filter_spec.rb b/spec/datagrid/filters/integer_filter_spec.rb
index 19ed985..0ffd5d9 100644
--- a/spec/datagrid/filters/integer_filter_spec.rb
+++ b/spec/datagrid/filters/integer_filter_spec.rb
@@ -11,10 +11,9 @@
   let(:entry7) { Entry.create!(group_id: 7) }
 
   it "should support integer range argument" do
-    report = test_report(group_id: 3..5) do
-      scope { Entry }
-      filter(:group_id, :integer, range: true)
-    end
+    report = test_grid_filter(:group_id, :integer, range: true)
+
+    report.group_id = 3..5
     expect(report.assets).not_to include(entry1)
     expect(report.assets).to include(entry4)
     expect(report.assets).not_to include(entry7)
@@ -29,49 +28,43 @@
   end
 
   it "should support integer range given as array argument" do
-    report = test_report(group_id: [3.to_s, 5.to_s]) do
-      scope { Entry }
-      filter(:group_id, :integer, range: true)
-    end
+    report = test_grid_filter(:group_id, :integer, range: true)
+    report.group_id = [3.to_s, 5.to_s]
     expect(report.group_id).to eq(3..5)
   end
 
   it "should support minimum integer argument" do
-    report = test_report(group_id: [5.to_s, nil]) do
-      scope { Entry }
-      filter(:group_id, :integer, range: true)
-    end
+    report = test_grid_filter(:group_id, :integer, range: true)
+    report.group_id = [5.to_s, nil]
+
     expect(report.group_id).to eq(5..)
   end
 
   it "should support maximum integer argument" do
-    report = test_report(group_id: [nil, 5.to_s]) do
-      scope { Entry }
-      filter(:group_id, :integer, range: true)
-    end
+    report = test_grid_filter(:group_id, :integer, range: true)
+    report.group_id = [nil, 5.to_s]
+
     expect(report.group_id).to eq(..5)
   end
 
   it "should find something in one integer interval" do
-    report = test_report(group_id: 4) do
-      scope { Entry }
-      filter(:group_id, :integer, range: true)
-    end
+    report = test_grid_filter(:group_id, :integer, range: true)
+    report.group_id = 4
+
     expect(report.assets).not_to include(entry7)
     expect(report.assets).to include(entry4)
     expect(report.assets).not_to include(entry1)
   end
 
   it "supports range inversion" do
-    report = test_report(group_id: (7..1)) do
-      scope { Entry }
-      filter(:group_id, :integer, range: true)
-    end
+    report = test_grid_filter(:group_id, :integer, range: true)
+    report.group_id = 7..1
+
     expect(report.group_id).to eq(1..7)
   end
 
   it "converts infinite range to nil" do
-    report = test_report(group_id: (nil..nil)) do
+    report = test_grid(group_id: (nil..nil)) do
       scope { Entry }
       filter(:group_id, :integer, range: true)
     end
@@ -79,18 +72,17 @@
   end
 
   it "should support block" do
-    report = test_report(group_id: 5) do
-      scope { Entry }
-      filter(:group_id, :integer, range: true) do |value|
-        where("group_id >= ?", value)
-      end
+    report = test_grid_filter(:group_id, :integer, range: true) do |value|
+      where("group_id >= ?", value)
     end
+    report.group_id = 5
+
     expect(report.assets).not_to include(entry1)
     expect(report.assets).to include(entry5)
   end
 
   it "should not prefix table name if column is joined" do
-    report = test_report(rating: [4, nil]) do
+    report = test_grid(rating: [4, nil]) do
       scope { Entry.joins(:group) }
       filter(:rating, :integer, range: true)
     end
@@ -100,20 +92,18 @@
   end
 
   it "should support multiple values" do
-    report = test_report(group_id: "1,2") do
-      scope { Entry }
-      filter(:group_id, :integer, multiple: true)
-    end
+    report = test_grid_filter(:group_id, :integer, multiple: true)
+    report.group_id = "1,2"
+
     expect(report.group_id).to eq([1, 2])
     expect(report.assets).to include(entry1)
     expect(report.assets).to include(entry2)
     expect(report.assets).not_to include(entry3)
   end
   it "should support custom separator multiple values" do
-    report = test_report(group_id: "1|2") do
-      scope { Entry }
-      filter(:group_id, :integer, multiple: "|")
-    end
+    report = test_grid_filter(:group_id, :integer, multiple: "|")
+    report.group_id = "1|2"
+
     expect(report.group_id).to eq([1, 2])
     expect(report.assets).to include(entry1)
     expect(report.assets).to include(entry2)
@@ -121,10 +111,8 @@
   end
 
   it "should support multiple with allow_blank allow_nil options" do
-    report = test_report do
-      scope { Entry }
-      filter(:group_id, :integer, multiple: true, allow_nil: false, allow_blank: true)
-    end
+    report = test_grid_filter(:group_id, :integer, multiple: true, allow_nil: false, allow_blank: true)
+
     report.group_id = []
     expect(report.assets).to_not include(entry1)
     expect(report.assets).to_not include(entry2)
@@ -137,20 +125,15 @@
   end
 
   it "normalizes AR object to ID" do
+    report = test_grid_filter(:group_id, :integer)
     group = Group.create!
-    report  = test_report(group_id: group) do
-      scope { Entry }
-      filter(:group_id, :integer)
-    end
+    report.group_id = group
 
     expect(report.group_id).to eq(group.id)
   end
 
   it "supports serialized range value" do
-    report  = test_report do
-      scope { Entry }
-      filter(:group_id, :integer, range: true)
-    end
+    report  = test_grid_filter(:group_id, :integer, range: true)
 
     report.group_id = (1..5).as_json
     expect(report.group_id).to eq(1..5)
@@ -172,10 +155,7 @@
   end
 
   it "type casts value" do
-    report = test_report do
-      scope { Entry }
-      filter(:group_id, :integer)
-    end
+    report = test_grid_filter(:group_id, :integer)
 
     report.group_id = "1"
     expect(report.group_id).to eq(1)
diff --git a/spec/datagrid/filters/string_filter_spec.rb b/spec/datagrid/filters/string_filter_spec.rb
index c55fb58..7463ead 100644
--- a/spec/datagrid/filters/string_filter_spec.rb
+++ b/spec/datagrid/filters/string_filter_spec.rb
@@ -4,19 +4,17 @@
 
 describe Datagrid::Filters::StringFilter do
   it "should support multiple values" do
-    report = test_report(name: "one,two") do
-      scope { Entry }
-      filter(:name, :string, multiple: true)
-    end
+    report = test_grid_filter(:name, :string, multiple: true)
+    report.name = "one,two"
+
     expect(report.assets).to include(Entry.create!(name: "one"))
     expect(report.assets).to include(Entry.create!(name: "two"))
     expect(report.assets).not_to include(Entry.create!(name: "three"))
   end
   it "should support custom separator multiple values" do
-    report = test_report(name: "one,1|two,2") do
-      scope { Entry }
-      filter(:name, :string, multiple: "|")
-    end
+    report = test_grid_filter(:name, :string, multiple: "|")
+    report.name = "one,1|two,2"
+
     expect(report.assets).to include(Entry.create!(name: "one,1"))
     expect(report.assets).to include(Entry.create!(name: "two,2"))
     expect(report.assets).not_to include(Entry.create!(name: "one"))
@@ -24,10 +22,9 @@
   end
 
   it "supports range" do
-    report = test_report(name: %w[ab lm]) do
-      scope { Entry }
-      filter(:name, :string, range: true)
-    end
+    report = test_grid_filter(:name, :string, range: true)
+    report.name = %w[ab lm]
+
     expect(report.assets).to include(Entry.create!(name: "ac"))
     expect(report.assets).to include(Entry.create!(name: "kl"))
     expect(report.assets).not_to include(Entry.create!(name: "aa"))
diff --git a/spec/datagrid/filters_spec.rb b/spec/datagrid/filters_spec.rb
index 67aa8db..7aa1a75 100644
--- a/spec/datagrid/filters_spec.rb
+++ b/spec/datagrid/filters_spec.rb
@@ -4,15 +4,17 @@
 
 describe Datagrid::Filters do
   it "should support default option as proc" do
-    expect(test_report do
-      scope { Entry }
-      filter(:created_at, :date, default: proc { Date.today })
-    end.created_at).to eq(Date.today)
+    expect(
+      test_grid_filter(
+        :created_at, :date, default: proc { Date.today }
+      ).created_at
+    ).to eq(Date.today)
+
   end
 
   it "should stack with other filters" do
     Entry.create(name: "ZZ", category: "first")
-    report = test_report(name: "Pop", category: "first") do
+    report = test_grid(name: "Pop", category: "first") do
       scope  { Entry }
       filter(:name)
       filter(:category, :enum, select: %w[first second])
@@ -21,21 +23,15 @@
   end
 
   it "should not support array argument for not multiple filter" do
-    report = test_report do
-      scope { Entry }
-      filter(:group_id, :integer)
-    end
+    report = test_grid_filter(:group_id, :integer)
     expect do
       report.group_id = [1, 2]
     end.to raise_error(Datagrid::ArgumentError)
   end
 
   it "should filter block with 2 arguments" do
-    report = test_report do
-      scope { Entry }
-      filter(:group_id, :integer) do |value, scope|
-        scope.where(group_id: value)
-      end
+    report = test_grid_filter(:group_id, :integer) do |value, scope|
+      scope.where(group_id: value)
     end
     expect do
       report.group_id = [1, 2]
@@ -69,13 +65,11 @@ class TheReport < Datagrid::Base
   describe "allow_blank and allow_nil options" do
     def check_performed(value, result, **options)
       filter_performed = false
-      report = test_report(name: value) do
-        scope { Entry }
-        filter(:name, **options) do |_|
-          filter_performed = true
-          self
-        end
+      report = test_grid_filter(:name, **options) do |_|
+        filter_performed = true
+        self
       end
+      report.name = value
       expect(report.name).to eq(value)
       report.assets
       expect(filter_performed).to eq(result)
@@ -102,29 +96,25 @@ def check_performed(value, result, **options)
     it "should create default filter if scope respond to filter name method" do
       Entry.create!
       Entry.create!
-      grid = test_report(limit: 1) do
-        scope { Entry }
-        filter(:limit)
-      end
+      grid = test_grid_filter(:limit)
+      grid.limit = 1
       expect(grid.assets.to_a.size).to eq(1)
     end
   end
   describe "default filter as scope" do
     it "should create default filter if scope respond to filter name method" do
       Entry.create!
-      grid = test_report(custom: "skip") do
-        scope { Entry }
-        filter(:custom) do |value|
-          where(custom: value) if value != "skip"
-        end
+      grid = test_grid_filter(:custom) do |value|
+        where(custom: value) if value != "skip"
       end
+      grid.custom = "skip"
       expect(grid.assets).not_to be_empty
     end
   end
 
   describe "positioning filter before another" do
     it "should insert the filter before the specified element" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         filter(:limit)
         filter(:name, before: :limit)
@@ -135,7 +125,7 @@ def check_performed(value, result, **options)
 
   describe "positioning filter after another" do
     it "should insert the filter before the specified element" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         filter(:limit)
         filter(:name)
@@ -146,17 +136,14 @@ def check_performed(value, result, **options)
   end
 
   it "should support dummy filter" do
-    grid = test_report do
-      scope { Entry }
-      filter(:period, :date, dummy: true, default: proc { Date.today })
-    end
+    grid = test_grid_filter(:period, :date, dummy: true, default: proc { Date.today })
     Entry.create!(created_at: 3.days.ago)
     expect(grid.assets).not_to be_empty
   end
 
   describe "#filter_by" do
     it "should allow partial filtering" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         filter(:id)
         filter(:name)
@@ -169,10 +156,7 @@ def check_performed(value, result, **options)
   end
 
   it "supports dynamic header" do
-    grid = test_report do
-      scope { Entry }
-      filter(:id, :integer, header: proc { rand(10**9) })
-    end
+    grid = test_grid_filter(:id, :integer, header: proc { rand(10**9) })
 
     filter = grid.filter_by_name(:id)
     expect(filter.header).to_not eq(filter.header)
@@ -180,10 +164,7 @@ def check_performed(value, result, **options)
 
   describe "#filter_by_name" do
     it "should return filter object" do
-      r = test_report do
-        scope { Entry }
-        filter(:id, :integer)
-      end
+      r = test_grid_filter(:id, :integer)
 
       object = r.filter_by_name(:id)
       expect(object.type).to eq(:integer)
@@ -230,7 +211,7 @@ class InheritedReport < TranslatedReport
         name: [["a", 1], ["b", 2]],
         category: { a: 1, b: 2 },
       }
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         filters.each do |name, options|
           filter(name, :enum, select: options, multiple: true)
@@ -245,10 +226,7 @@ class InheritedReport < TranslatedReport
     end
 
     it "should raise ArgumentError for filter without options" do
-      grid = test_report do
-        scope { Entry }
-        filter(:id, :integer)
-      end
+      grid = test_grid_filter(:id, :integer)
       expect do
         grid.select_options(:id)
       end.to raise_error(Datagrid::ArgumentError)
@@ -282,7 +260,7 @@ class TestGrid8728 < Datagrid::Base
 
   describe ":if :unless options" do
     it "supports :if option" do
-      klass = test_report_class do
+      klass = test_grid_class do
         scope { Entry }
         filter(:admin_mode, :boolean, dummy: true)
         filter(:id, :integer, if: :admin_mode)
@@ -300,7 +278,7 @@ class TestGrid8728 < Datagrid::Base
     context "with delegation to attribute" do
       let(:role) { Struct.new(:admin).new(admin) }
       let(:klass) do
-        test_report_class do
+        test_grid_class do
           attr_accessor :role
 
           delegate :admin, to: :role
diff --git a/spec/datagrid/form_builder_spec.rb b/spec/datagrid/form_builder_spec.rb
index 0ce24e3..4fbf5b5 100644
--- a/spec/datagrid/form_builder_spec.rb
+++ b/spec/datagrid/form_builder_spec.rb
@@ -36,10 +36,7 @@ class MyTemplate
 
     context "with default filter type" do
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(:name)
-        end
+        test_grid_filter(:name)
       end
 
       let(:_filter) { :name }
@@ -53,10 +50,7 @@ class MyTemplate
     context "with integer filter type" do
       let(:_filter) { :group_id }
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(:group_id, :integer)
-        end
+        test_grid_filter(:group_id, :integer)
       end
 
       it {
@@ -79,10 +73,7 @@ class MyTemplate
     context "with date filter type" do
       let(:_filter) { :created_at }
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(:created_at, :date)
-        end
+        test_grid_filter(:created_at, :date)
       end
 
       it {
@@ -111,10 +102,7 @@ class MyTemplate
       context "date filter type is text" do
         let(:_filter) { :created_at }
         let(:_grid) do
-          test_report do
-            scope { Entry }
-            filter(:created_at, :date, input_options: { type: "text" })
-          end
+          test_grid_filter(:created_at, :date, input_options: { type: 'text' })
         end
 
         it {
@@ -127,10 +115,7 @@ class MyTemplate
       context "string filter type is textarea" do
         let(:_filter) { :name }
         let(:_grid) do
-          test_report do
-            scope { Entry }
-            filter(:name, :string, input_options: { type: :textarea })
-          end
+          test_grid_filter(:name, :string, input_options: { type: :textarea })
         end
 
         it {
@@ -146,7 +131,7 @@ class MyTemplate
           created_at = ActiveSupport::TimeZone["UTC"].local(
             2024, 1, 1, 9, 25, 15,
           )
-          test_report(created_at: created_at) do
+          test_grid(created_at: created_at) do
             scope { Entry }
             filter(:created_at, :datetime, input_options: { type: "text" })
           end
@@ -174,7 +159,7 @@ class MyTemplate
       context "datetime filter type is date" do
         let(:_filter) { :created_at }
         let(:_grid) do
-          test_report(created_at: Date.new(2024, 1, 1)) do
+          test_grid(created_at: Date.new(2024, 1, 1)) do
             scope { Entry }
             filter(:created_at, :datetime, input_options: { type: :date })
           end
@@ -193,10 +178,9 @@ class MyTemplate
     context "with integer filter type and range option" do
       let(:_filter) { :group_id }
       let(:_grid) do
-        test_report(group_id: _range) do
-          scope { Entry }
-          filter(:group_id, :integer, range: true)
-        end
+        grid = test_grid_filter(:group_id, :integer, range: true)
+        grid.group_id = _range
+        grid
       end
 
       context "when datagrid_filter options has id" do
@@ -278,7 +262,7 @@ class MyTemplate
     context "with float filter type and range option" do
       let(:_filter) { :rating }
       let(:_grid) do
-        test_report(rating: _range) do
+        test_grid(rating: _range) do
           scope { Group }
           filter(:rating, :float, range: true)
         end
@@ -297,7 +281,7 @@ class MyTemplate
     context "with date filter type and range option" do
       let(:_filter) { :created_at }
       let(:_grid) do
-        test_report(created_at: _range) do
+        test_grid(created_at: _range) do
           scope { Entry }
           filter(:created_at, :date, range: true)
         end
@@ -378,10 +362,7 @@ class MyTemplate
       let(:_category_filter_options) { {} }
       let(:_grid) do
         filter_options = _category_filter_options
-        test_report do
-          scope { Entry }
-          filter(:category, :enum, select: %w[first second], **filter_options)
-        end
+        test_grid_filter(:category, :enum, select: %w[first second], **filter_options)
       end
 
       it {
@@ -547,10 +528,7 @@ class MyTemplate
     context "with boolean filter type" do
       let(:_filter) { :disabled }
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(:disabled, :boolean, default: true)
-        end
+        test_grid_filter(:disabled, :boolean, default: true)
       end
 
       it {
@@ -564,10 +542,7 @@ class MyTemplate
     context "with xboolean filter type" do
       let(:_filter) { :disabled }
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(:disabled, :xboolean)
-        end
+        test_grid_filter(:disabled, :xboolean)
       end
       it {
         should equal_to_dom(
@@ -580,10 +555,7 @@ class MyTemplate
     end
     context "with string filter" do
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(:name, :string)
-        end
+        test_grid_filter(:name, :string)
       end
 
       let(:_filter) { :name }
@@ -592,7 +564,7 @@ class MyTemplate
 
       context "when multiple option is set" do
         let(:_grid) do
-          test_report(name: "one,two") do
+          test_grid(name: "one,two") do
             scope { Entry }
             filter(:name, :string, multiple: true)
           end
@@ -610,25 +582,19 @@ class MyTemplate
 
     context "with non multiple filter" do
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(
-            :name, :enum,
-            include_blank: false,
-            multiple: false,
-            select: [],
-          )
-        end
+        test_grid_filter(
+          :name, :enum,
+          include_blank: false,
+          multiple: false,
+          select: [],
+        )
       end
       let(:_filter) { :name }
       it { should equal_to_dom('<select name="report[name]" id="report_name"></select>') }
     end
     context "with float filter type" do
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(:group_id, :float)
-        end
+        test_grid_filter(:group_id, :float)
       end
       let(:_filter) { :group_id }
       it {
@@ -640,10 +606,7 @@ class MyTemplate
 
     context "with enum multiple filter" do
       let(:_grid) do
-        test_report do
-          scope { Entry }
-          filter(:group_id, :enum, select: ["hello"], multiple: true)
-        end
+        test_grid_filter(:group_id, :enum, select: ["hello"], multiple: true)
       end
       let(:_filter) { :group_id }
       let(:expected_html) do
@@ -658,7 +621,7 @@ class MyTemplate
 
     context "with column names filter" do
       let(:_grid) do
-        test_report(column_names: %i[id name]) do
+        test_grid(column_names: %i[id name]) do
           scope { Entry }
 
           column_names_filter
@@ -681,7 +644,7 @@ class MyTemplate
     end
     context "with column_names_filter default given as symbols" do
       let(:_grid) do
-        test_report do
+        test_grid do
           scope { Entry }
 
           column_names_filter(default: %i[id name], checkboxes: true)
@@ -723,10 +686,7 @@ class MyTemplate
 
       let(:_grid) do
         options = filter_options
-        test_report do
-          scope { Entry }
-          filter(:condition, :dynamic, **options)
-        end
+        test_grid_filter(:condition, :dynamic, **options)
       end
       let(:_filter) { :condition }
       context "with no options" do
@@ -813,7 +773,7 @@ class MyTemplate
 
   describe ".datagrid_label" do
     let(:_grid) do
-      test_report do
+      test_grid do
         scope { Entry }
         filter(:name, :string)
         filter(:created_at, :date, label_options: { class: "js-date-selector" })
diff --git a/spec/datagrid/helper_spec.rb b/spec/datagrid/helper_spec.rb
index ce89042..0c7bce9 100644
--- a/spec/datagrid/helper_spec.rb
+++ b/spec/datagrid/helper_spec.rb
@@ -37,7 +37,7 @@
 
   context "when grid has no records" do
     let(:grid) do
-      test_report do
+      test_grid do
         scope { Entry.where("1 != 1") }
         column(:id)
       end
@@ -102,7 +102,7 @@
 
     context "with column_names attribute" do
       let(:grid) do
-        test_report(column_names: "name") do
+        test_grid(column_names: "name") do
           scope { Entry }
           column(:name)
           column(:category)
@@ -121,9 +121,7 @@
 
     context "when grid has no columns" do
       let(:grid) do
-        test_report do
-          scope { Entry }
-        end
+        test_grid
       end
 
       it "should render no_columns message" do
@@ -133,7 +131,7 @@
 
     context "with partials attribute" do
       let(:grid) do
-        test_report do
+        test_grid do
           scope { Entry }
           column(:name)
           column(:category)
@@ -152,7 +150,7 @@
 
     context "when scope is enumerator" do
       let(:grid) do
-        test_report do
+        test_grid do
           scope { %w[a b].to_enum }
           column(:name) do |value|
             value
@@ -168,7 +166,7 @@
     end
     context "when scope is lazy enumerator" do
       let(:grid) do
-        test_report do
+        test_grid do
           scope { %w[a b].lazy }
           column(:name) do |value|
             value
@@ -186,19 +184,17 @@
 
   describe ".datagrid_rows" do
     it "should add ordering classes to column" do
-      rp = test_report(order: :name) do
-        scope { Entry }
-        column(:name)
-      end
+      rp = test_grid_column(:name)
+      rp.order = :name
+
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name].datagrid-order-active-asc" => "Star",
       )
     end
     it "should add ordering classes to column" do
-      rp = test_report(order: :name) do
-        scope { Entry }
-        column(:name)
-      end
+      rp = test_grid_column(:name)
+      rp.order = :name
+
       expect(
         subject.datagrid_rows(rp) do |row|
           subject.tag.strong(row.name)
@@ -209,20 +205,17 @@
     end
 
     it "should add ordering classes to column" do
-      rp = test_report(order: :name, descending: true) do
-        scope { Entry }
-        column(:name)
-      end
+      rp = test_grid_column(:name)
+      rp.order = :name
+      rp.descending = true
+
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name].datagrid-order-active-desc" => "Star",
       )
     end
 
     it "should render columns with &:symbol block" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, &:name)
-      end
+      rp = test_grid_column(:name, &:name)
 
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name]" => "Star",
@@ -230,11 +223,8 @@
     end
 
     it "should render html columns" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: true) do |model|
-          tag.span(model.name)
-        end
+      rp = test_grid_column(:name, html: true) do |model|
+        tag.span(model.name)
       end
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name] span" => "Star",
@@ -242,10 +232,7 @@
     end
 
     it "should render :html columns with &:symbol block" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: true, &:name)
-      end
+      rp = test_grid_column(:name, html: true, &:name)
 
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name]" => "Star",
@@ -253,7 +240,7 @@
     end
 
     it "should render format columns with &:symbol block" do
-      rp = test_report do
+      rp = test_grid do
         scope { Entry }
         column(:name) do |record|
           format(record, &:name)
@@ -266,10 +253,7 @@
     end
 
     it "should render :html columns with &:symbol block with a data attribute" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: true, data: "DATA", &:name)
-      end
+      rp = test_grid_column(:name, html: true, data: "DATA", &:name)
 
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name]" => "Star",
@@ -277,21 +261,15 @@
     end
 
     it "should render argument-based html columns" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: ->(data) { tag.h1 data })
-      end
+      rp = test_grid_column(:name, html: ->(data) { tag.h1 data })
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name] h1" => "Star",
       )
     end
 
     it "should render argument-based html columns with custom data" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: ->(data) { tag.em data }) do
-          name.upcase
-        end
+      rp = test_grid_column(:name, html: ->(data) { tag.em data }) do
+        name.upcase
       end
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name] em" => "STAR",
@@ -299,11 +277,8 @@
     end
 
     it "should render html columns with double arguments for column" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: true) do |model, grid|
-          tag.span("#{model.name}-#{grid.assets.klass}")
-        end
+      rp = test_grid_column(:name, html: true) do |model, grid|
+        tag.span("#{model.name}-#{grid.assets.klass}")
       end
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name] span" => "Star-Entry",
@@ -311,37 +286,28 @@
     end
 
     it "should render argument-based html blocks with double arguments" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: lambda { |data, model|
-          tag.h1 "#{data}-#{model.name.downcase}"
-        },)
-      end
+      rp = test_grid_column(:name, html: lambda { |data, model|
+        tag.h1 "#{data}-#{model.name.downcase}"
+      })
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name] h1" => "Star-star",
       )
     end
 
     it "should render argument-based html blocks with triple arguments" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: lambda { |data, model, grid|
-          content_tag :h1, "#{data}-#{model.name.downcase}-#{grid.assets.klass}"
-        },)
-      end
+      rp = test_grid_column(:name, html: lambda { |data, model, grid|
+        content_tag :h1, "#{data}-#{model.name.downcase}-#{grid.assets.klass}"
+      })
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name] h1" => "Star-star-Entry",
       )
     end
 
     it "should render argument-based html blocks with double arguments and custom data" do
-      rp = test_report do
-        scope { Entry }
-        column(:name, html: lambda { |data, model|
-          content_tag :h1, "#{data}-#{model.name}"
-        },) do
-          name.upcase
-        end
+      rp = test_grid_column(:name, html: lambda { |data, model|
+        content_tag :h1, "#{data}-#{model.name}"
+      }) do
+        name.upcase
       end
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
         "tr td[data-column=name] h1" => "STAR-Star",
@@ -349,7 +315,7 @@
     end
 
     it "should render argument-based html blocks with triple arguments and custom data" do
-      rp = test_report do
+      rp = test_grid do
         scope { Entry }
         column(:name, html: lambda { |data, model, grid|
           content_tag :h1, "#{data}-#{model.name}-#{grid.assets.klass}"
@@ -363,7 +329,7 @@
     end
 
     it "should support columns option" do
-      rp = test_report do
+      rp = test_grid do
         scope { Entry }
         column(:name)
         column(:category)
@@ -378,10 +344,7 @@
 
     it "should allow CSS classes to be specified for a column" do
       rp = expect_deprecated do
-        test_report do
-          scope { Entry }
-          column(:name, class: "my-class")
-        end
+        test_grid_column(:name, class: "my-class")
       end
 
       expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
@@ -390,7 +353,7 @@
     end
 
     it "supports tag_options option" do
-      report = test_report(order: :name, descending: true) do
+      report = test_grid(order: :name, descending: true) do
         scope { Entry }
         column(:name, tag_options: {
           class: 'my-class',
@@ -408,7 +371,7 @@
 
     context "when grid has complicated columns" do
       let(:grid) do
-        test_report(name: "Hello") do
+        test_grid(name: "Hello") do
           scope { Entry }
           filter(:name)
           column(:name) do |model, grid|
@@ -611,7 +574,7 @@ def param_name
 
   describe ".datagrid_row" do
     let(:grid) do
-      test_report do
+      test_grid do
         scope { Entry }
         column(:name)
         column(:category)
@@ -657,7 +620,7 @@ def param_name
     end
 
     it "should use cache" do
-      grid = test_report do
+      grid = test_grid do
         scope { Entry }
         self.cached = true
         column(:random1, html: true) { rand(10**9) }
@@ -688,7 +651,7 @@ def param_name
 
   describe ".datagrid_value" do
     it "should format value by column name" do
-      report = test_report do
+      report = test_grid do
         scope { Entry }
         column(:name) do |e|
           "<b>#{e.name}</b>"
@@ -698,7 +661,7 @@ def param_name
       expect(subject.datagrid_value(report, :name, entry)).to eq("<b>Star</b>")
     end
     it "should support format in column" do
-      report = test_report do
+      report = test_grid do
         scope { Entry }
         column(:name) do |e|
           format(e.name) do |value|
@@ -711,7 +674,7 @@ def param_name
     end
 
     it "applies decorator" do
-      report = test_report do
+      report = test_grid do
         scope { Entry }
         decorate do |_model|
           Class.new(Struct.new(:model)) do
@@ -729,7 +692,7 @@ def name
 
   describe ".datagrid_header" do
     it "should support order_by_value colums" do
-      grid = test_report(order: "category") do
+      grid = test_grid(order: "category") do
         scope { Entry }
         column(:category, order: false, order_by_value: true)
 
@@ -746,7 +709,7 @@ def param_name
     end
 
     it "supports tag_options option" do
-      grid = test_report(order: :name, descending: true) do
+      grid = test_grid(order: :name, descending: true) do
         scope { Entry }
         column(:name, order: false, tag_options: {
           class: 'my-class',
@@ -765,7 +728,7 @@ def param_name
 
   describe ".datagrid_column_classes" do
     it "is deprecated" do
-      grid = test_report(order: :name, descending: true) do
+      grid = test_grid(order: :name, descending: true) do
         scope { Entry }
         column(:name)
         column(:group_id, class: "short-column")
diff --git a/spec/datagrid/ordering_spec.rb b/spec/datagrid/ordering_spec.rb
index a6306d3..add3ecb 100644
--- a/spec/datagrid/ordering_spec.rb
+++ b/spec/datagrid/ordering_spec.rb
@@ -8,7 +8,7 @@
   let!(:first) { Entry.create!(name: "aa") }
 
   it "should support order" do
-    expect(test_report(order: "name") do
+    expect(test_grid(order: "name") do
       scope do
         Entry
       end
@@ -17,7 +17,7 @@
   end
 
   it "should support desc order" do
-    expect(test_report(order: "name", descending: true) do
+    expect(test_grid(order: "name", descending: true) do
       scope do
         Entry
       end
@@ -27,13 +27,13 @@
 
   it "should raise error if ordered by not existing column" do
     expect do
-      test_report(order: :hello).assets
+      test_grid(order: :hello).assets
     end.to raise_error(Datagrid::OrderUnsupported)
   end
 
   it "should raise error if ordered by column without order" do
     expect do
-      test_report(order: :category) do
+      test_grid(order: :category) do
         filter(:category, :default, order: false) do |_value|
           self
         end
@@ -42,42 +42,42 @@
   end
 
   it "should override default order" do
-    expect(test_report(order: :name) do
+    expect(test_grid(order: :name) do
       scope { Entry.order("name desc") }
       column(:name, order: "name asc")
     end.assets).to eq([first, second, third])
   end
 
   it "should support order given as block" do
-    expect(test_report(order: :name) do
+    expect(test_grid(order: :name) do
       scope { Entry }
       column(:name, order: proc { order("name desc") })
     end.assets).to eq([third, second, first])
   end
 
   it "should support reversing order given as block" do
-    expect(test_report(order: :name, descending: true) do
+    expect(test_grid(order: :name, descending: true) do
       scope { Entry }
       column(:name, order: proc { order("name desc") })
     end.assets).to eq([first, second, third])
   end
 
   it "should support order desc given as block" do
-    expect(test_report(order: :name, descending: true) do
+    expect(test_grid(order: :name, descending: true) do
       scope { Entry }
       column(:name, order_desc: proc { order("name desc") })
     end.assets).to eq([third, second, first])
   end
 
   it "should treat true order as default" do
-    expect(test_report(order: :name) do
+    expect(test_grid(order: :name) do
       scope { Entry }
       column(:name, order: true)
     end.assets).to eq([first, second, third])
   end
 
   it "should support order_by_value" do
-    report = test_report(order: :the_name) do
+    report = test_grid(order: :the_name) do
       scope { Entry }
       column(:the_name, order_by_value: true) do
         name
@@ -90,7 +90,7 @@
 
   it "should support order_by_value as block" do
     order = { aa: 2, bb: 3, cc: 1 }
-    report = test_report(order: :the_name) do
+    report = test_grid(order: :the_name) do
       scope { Entry }
       column(:the_name, order_by_value: proc { |model| order[model.name.to_sym] }) do
         name
@@ -116,7 +116,7 @@ class OrderInheritenceChild < OrderInheritenceBase
     expect(grid.assets).to eq([third, second, first])
   end
   it "should support ordering by dynamic columns" do
-    report = test_report(order: "name") do
+    report = test_grid(order: "name") do
       scope { Entry }
       dynamic do
         column(:name)
@@ -127,7 +127,7 @@ class OrderInheritenceChild < OrderInheritenceBase
   end
 
   it "should support #ordered_by? method" do
-    report = test_report(order: "name") do
+    report = test_grid(order: "name") do
       scope  { Entry }
       column(:id)
       column(:name)
diff --git a/spec/datagrid_spec.rb b/spec/datagrid_spec.rb
index 60ca8de..4f34558 100644
--- a/spec/datagrid_spec.rb
+++ b/spec/datagrid_spec.rb
@@ -46,7 +46,7 @@
 
     context "when not defined on class level" do
       subject do
-        test_report do
+        test_grid do
           column(:id)
         end
       end
@@ -68,7 +68,7 @@
 
     context "when defined in the grid class" do
       subject do
-        test_report do
+        test_grid do
           self.batch_size = 25
         end
       end
@@ -80,7 +80,7 @@
 
     context "when set to nil in the grid class" do
       subject do
-        test_report do
+        test_grid do
           self.batch_size = nil
         end
       end
diff --git a/spec/support/simple_report.rb b/spec/support/simple_report.rb
index 7b5bfeb..d74ac47 100644
--- a/spec/support/simple_report.rb
+++ b/spec/support/simple_report.rb
@@ -1,18 +1,36 @@
 # frozen_string_literal: true
 
-def test_report(attributes = {}, &block)
-  klass = test_report_class(&block)
+def test_grid(attributes = {}, &block)
+  klass = test_grid_class(&block)
   klass.new(attributes)
 end
 
-def test_report_class(&block)
+def test_grid_class(&block)
   Class.new(Datagrid::Base).tap do |klass|
     klass.class_eval do
       def self.name
         "TestGrid"
       end
     end
-    klass.class_eval(&block) if block
+    if block
+      klass.class_eval(&block)
+    else
+      klass.scope { Entry }
+    end
+  end
+end
+
+def test_grid_column(name, query = nil, **options, &block)
+  test_grid do
+    scope { Entry }
+    column(name, query, **options, &block)
+  end
+end
+
+def test_grid_filter(name, type = :default, **options, &block)
+  test_grid do
+    scope { Entry }
+    filter(name, type, **options, &block)
   end
 end