google_data_source 0.7.6

data/test/locales/en.models.yml

@@ -0,0 +1,6 @@
+en:
+  models:
+    attributes:
+      test_reporting:
+        address: AddressModels
+        age: AgeModels

data/test/locales/en.reportings.yml

@@ -0,0 +1,5 @@
+en:
+  reportings:
+    test_reporting:
+      name: NameReportings
+      age: AgeReportings

data/test/rails/reporting_renderer_test.rb

@@ -0,0 +1,47 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+
+# require 'rails'
+# require 'google_data_source/railtie'
+# GoogleDataSource::Railtie.run_initializers
+
+
+class ReportingRendererTest < Test::Unit::TestCase
+
+
+  # test "render" do
+  #   class TestController < ActionController::Base
+  #     def params
+  #       {}
+  #     end
+      
+  #     def test(reporting)
+  #       render :reporting => reporting
+  #     end
+
+  #     def regular
+  #       render :text => "foo"
+  #     end
+  #   end
+
+  #   class TestReporting < ::Reporting
+  #   end
+
+  #   reporting  = TestReporting.new
+  #   controller = TestController.new
+  #   datasource = GoogleDataSource::DataSource::Base.from_params(:reqId => 123)
+
+  #   # stubs
+  #   controller.stubs(:render_for_text).returns('')
+  #   GoogleDataSource::DataSource::Base.stubs(:from_params).returns(datasource)
+
+  #   # regular rendering should still work
+  #   controller.expects(:render_without_reporting).with({:text => "foo"})
+
+  #   # the response of the data source has to be generated
+  #   datasource.expects(:response).returns("")
+
+  #   controller.test(reporting)
+  #   controller.regular
+  # end
+end

data/test/test_helper.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+require 'bundler/setup'
+
+# TODO: move to rr?
+require 'mocha'
+
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'google_data_source'
+
+class Test::Unit::TestCase
+end
+
+
+# Setup I18n stuff
+I18n.load_path << Dir[File.join(File.expand_path(File.dirname(__FILE__)), 'locales', '*.yml')]
+I18n.default_locale = :en
+
+# Setup Database and Models
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => ":memory:"
+)
+
+def setup_db
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Schema.define do
+    create_table "items", :force => true do |t|
+      t.column "name", :string
+      t.column "description", :text
+      t.column "number", :integer
+      t.column "datetime", :datetime
+      t.column "date", :date
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class Item < ActiveRecord::Base; end

data/test/units/base_test.rb

@@ -0,0 +1,340 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+require 'test_reporting'
+require 'test_reporting_b'
+
+class TestReportingForBaseTest < Reporting
+  column :name, :type => :string
+  column :age,  :type => :number
+
+  def aggregate
+    [
+      { :name => "John", :age => 20 },
+      { :name => "Jim",  :age => 30 }
+    ]
+  end
+
+  def select
+    %w(name age)
+  end
+end
+
+class TestAggregator
+  attr_reader :columns
+  attr_writer :valid
+
+  def initialize(data, columns)
+    @valid = true
+    @data = data
+    @columns = columns
+  end
+
+  def data(options = {})
+    @data
+  end
+
+  def callback
+    "alert('foo');"
+  end
+
+  def valid?
+    @valid
+  end
+end
+
+class BaseTest < ActiveSupport::TestCase
+  include GoogleDataSource::DataSource
+
+  def setup
+    setup_db
+    @reporting = TestReportingForBaseTest.new
+    @datasource = Base.from_params({})
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  test "from_params should parse the tqx parameter" do
+    datasource = Base.from_params({ :tqx => 'reqId:123;out:csv;version:0.5' })
+    assert_equal '123', datasource[:reqId]
+    assert_equal 'csv', datasource[:out]
+    assert_equal '0.5', datasource[:version]
+  end
+
+  test "the tqx should be settable via []=" do
+    @datasource[:reqId] = '123'
+    assert_equal '123', response_hash(@datasource)['reqId']
+  end
+
+  test "response should include the right reqId" do
+    datasource = GoogleDataSource::DataSource::Base.from_params({ :tqx => 'reqId:123' })
+    response = response_hash(datasource)
+    assert_equal '123', response['reqId']
+  end
+
+  test "from_params should consider the out parameter" do
+    datasource = Base.from_gdata_params({ :out => 'csv' })
+    assert datasource.is_a?(CsvData)
+    datasource = Base.from_gdata_params({ :out => 'html' })
+    assert datasource.is_a?(HtmlData)
+    datasource = Base.from_gdata_params({ :out => 'json' })
+    assert datasource.is_a?(JsonData)
+    datasource = Base.from_gdata_params({ :out => '' })
+    assert datasource.is_a?(InvalidData)
+  end
+
+  test "should return the right format" do
+    datasource = Base.from_gdata_params({ :out => 'csv' })
+    assert_equal 'csv', datasource.format
+    datasource = Base.from_gdata_params({ :out => 'json' })
+    assert_equal 'json', datasource.format
+    datasource = Base.from_gdata_params({ :out => 'html' })
+    assert_equal 'html', datasource.format
+  end
+
+  test "should be invalid if an error is added" do
+    assert @datasource.valid?
+    @datasource.add_error(:foo, 'bar')
+    assert !@datasource.valid?
+  end
+
+  test "should be invalid if no reqId is given" do
+    datasource = Base.from_params({:tqx => "out:csv"})
+    datasource.validate
+    assert !datasource.valid?
+  end
+
+  test "invalidity if version is not supported" do
+    datasource = Base.from_params({:tqx => "reqId:0;version:0.5"})
+    datasource.validate
+    assert !datasource.valid?
+  end
+
+  test "invalidity if output format is not supported" do
+    datasource = Base.from_params({:tqx => "reqId:0;out:pdf"})
+    datasource.validate
+    assert !datasource.valid?
+  end
+
+  test "guess_columns" do
+    items = [Item.create(:name => "name", :description => "description", :number => 0)]
+    columns = @datasource.guess_columns(items)
+
+    col_name        = columns.select{|c| c.id == :name}.first
+    col_description = columns.select{|c| c.id == :description}.first
+    col_number      = columns.select{|c| c.id == :number}.first
+
+    assert !col_name.nil?
+    assert !col_description.nil?
+    assert !col_number.nil?
+
+    # TODO check types
+  end
+
+  test "columns setter should convert hashes to Column objects" do
+    @datasource.columns = [
+      { :id => 'foo', :type => :string }
+    ]
+    assert_equal 1, @datasource.columns.size
+    assert_kind_of Column, @datasource.columns.first
+  end
+
+  test "throw exception on invalid column type" do
+    assert_raise ArgumentError do
+      @datasource.columns = [
+        { :id => 'foo', :type => :bar }
+      ]
+    end
+  end
+
+  test "set with array as data and columns array" do
+    @datasource.set(test_data, test_columns)
+    raw_data = @datasource.instance_variable_get(:@raw_data)
+    assert_equal test_data, raw_data
+    assert_equal 2, @datasource.columns.size
+    assert_equal :name, @datasource.columns.first.id
+    assert_equal :age,  @datasource.columns.last.id
+  end
+
+  test "set with an aggregator class" do
+    @datasource.set(test_aggregator)
+
+    # check for columns
+    assert_equal 2, @datasource.columns.size
+    assert_equal :name, @datasource.columns.first.id
+
+    # check for data
+    assert_equal "John", @datasource.data.first[0]
+    assert_equal 20, @datasource.data.first[1]
+  end
+
+  test "simple response" do
+    @datasource.set(test_aggregator)
+    result = response_hash(@datasource)
+    assert_equal '0.6',   result['version']
+    assert_equal 2,       result['table']['cols'].size
+    assert_equal 'name',  result['table']['cols'].first['id']
+    assert_equal 'string',result['table']['cols'].first['type']
+    assert_equal 'John',  result['table']['rows'].first['c'].first['v']
+  end
+
+  test "formatter" do
+    @datasource.set(test_aggregator)
+    @datasource.formatter :name do |row|
+      "<strong>#{row.name}</strong>"
+    end
+    data = response_data(@datasource)
+    assert_equal "John",                  data.first[0]['v']
+    assert_equal "<strong>John</strong>", data.first[0]['f']
+  end
+
+  test "formatter should add required columns" do
+    aggregator = TestAggregator.new(test_data, [{ :id => :name, :type => :string }])
+    @datasource.set(aggregator)
+    # should only require name column
+    assert_equal 1, @datasource.required_columns.size
+
+    # should also require age column
+    @datasource.formatter :name, :requires => [:age] do |row|
+      "foo"
+    end
+    assert_equal 2, @datasource.required_columns.size
+    assert @datasource.required_columns.include?('name')
+    assert @datasource.required_columns.include?('age')
+  end
+
+  test "has_formatter?" do
+    assert ! @datasource.has_formatter?(:name)
+    @datasource.formatter :name do |row|
+      "foo"
+    end
+    assert @datasource.has_formatter?(:name)
+  end
+
+  test "column_ids" do
+    @datasource.set(test_aggregator)
+    assert_equal %w(name age).collect(&:to_sym), @datasource.column_ids
+  end
+
+  test "virtual_column" do
+    aggregator = TestAggregator.new(test_data, [{ :id => :summary, :type => :string }])
+    @datasource.set(aggregator)
+    @datasource.virtual_column :summary do |row|
+      "#{row.name} - #{row.age}"
+    end
+
+    data = response_data(@datasource)
+    assert_equal "John - 20", data[0][0]['v']
+    assert_equal "Jim - 30",  data[1][0]['v']
+  end
+
+  test "is_virtual_column?" do
+    assert ! @datasource.is_virtual_column?(:summary)
+    @datasource.virtual_column :summary do |row|
+      "foo"
+    end
+    assert @datasource.is_virtual_column?(:summary)
+  end
+
+  test "virtual_column should add required columns if given as option" do
+    aggregator = TestAggregator.new(test_data, [{ :id => :name, :type => :string }, { :id => :summary }])
+    @datasource.set(aggregator)
+
+    assert_equal 2, @datasource.required_columns.size
+    @datasource.virtual_column :summary, :requires => [:age] do |row|
+      "foo"
+    end
+    assert_equal 3, @datasource.required_columns.size
+  end
+
+  test "virtual_column should try to inform the aggregator about the column definition, virtual_column first" do
+    aggregator = test_aggregator
+    aggregator.expects(:add_virtual_column).with(:summary, :string)
+
+    @datasource.virtual_column :summary do |row|
+      "#{row.name} - #{row.age}"
+    end
+    @datasource.set(aggregator)
+  end
+
+  test "virtual_column should try to inform the aggregator about the column definition, set first" do
+    aggregator = test_aggregator
+    aggregator.expects(:add_virtual_column).with(:summary, :string)
+
+    @datasource.set(aggregator)
+    @datasource.virtual_column :summary do |row|
+      "#{row.name} - #{row.age}"
+    end
+  end
+
+  test "set column label" do
+    @datasource.set(test_aggregator)
+    @datasource.column_labels = {
+      :name => "Name"
+    }
+    columns = response_columns(@datasource)
+    #puts columns.inspect
+    assert_equal "Name", columns.first['label']
+  end
+
+  test "should turn invalid if aggregator is invalid" do
+    aggregator = test_aggregator
+    @datasource.set(aggregator)
+    @datasource.data
+    assert @datasource.valid?
+
+    aggregator.valid = false
+    @datasource.set(aggregator)
+    @datasource.data
+    assert ! @datasource.valid?
+  end
+
+  test "should render error if invalid" do
+    aggregator = test_aggregator
+    aggregator.valid = false
+    @datasource.set(aggregator)
+    response = response_hash(@datasource)
+    #puts response.inspect
+    assert_equal 'error', response['status']
+  end
+
+  test "should correctly set columns in hierarchy" do
+    # verify that the class_inheritable_accessor stuff is migrated correctly
+    assert_equal %w{name age address fullname fullfullname circle_a circle_b}.sort, 
+                TestReporting.datasource_columns.keys.sort
+    assert_equal %w{name age address fullname fullfullname circle_a circle_b name_b age_b}.sort, 
+                TestReportingB.datasource_columns.keys.sort
+  end
+
+  def test_data
+    [
+      { :name => "John", :age => 20},
+      { :name => "Jim",  :age => 30}
+    ]
+  end
+
+  def test_columns
+    [
+      { :id => :name, :type => :string },
+      { :id => 'age', :type => :number}
+    ]
+  end
+
+  def test_aggregator
+    TestAggregator.new(test_data, test_columns)
+  end
+
+  def response_hash(datasource)
+    json = datasource.response.match(/setResponse\(({.*})\)/)[1]
+    ActiveSupport::JSON.decode(json)
+  end
+
+  def response_columns(datasource)
+    response_hash(datasource)['table']['cols']
+  end
+
+  def response_data(datasource)
+    response_hash(datasource)['table']['rows'].collect { |r| r['c'] }
+  end
+
+end