ruport 0.8.14 → 0.10.0

data/test/test_config.rb

@@ -1,88 +0,0 @@
-require "test/unit"
-require "ruport"
-
-class TestConfiguration < Test::Unit::TestCase
-
-  def setup
-    Ruport::Config.log_file = "test/unit.log"
-  end
-  
-  def test_dsn_defaults
-    assert_equal(nil, Ruport::Config.default_source)
-  end
-
-  def test_mail_defaults
-    assert_equal(nil, Ruport::Config.default_mailer)
-  end
-
-  def test_missing_dsn
-   assert_raise(ArgumentError) {
-     Ruport::Config.source :foo, :user => "root", :password => "fff"
-   }
-   assert_nothing_raised { Ruport::Config.source :bar, :dsn => "..." }
-  end
-
-  def test_mailer_errors
-    assert_raise(ArgumentError) {
-      Ruport::Config.mailer :bar, :user => :foo, :address => "foo@bar.com"
-    }
-    assert_nothing_raised { Ruport::Config.mailer :bar, :host => "localhost" }
-  end
-
-  def test_new_defaults
-   Ruport::Config.source :default, :dsn      => "dbi:mysql:test",
-                                   :user     => "root",
-                                   :password => ""
-   assert_equal("dbi:mysql:test", Ruport::Config.default_source.dsn)
-   assert_equal("root", Ruport::Config.default_source.user)
-   assert_equal("", Ruport::Config.default_source.password)
-  end
-
-  def test_multiple_sources
-    Ruport::Config.source :foo, :dsn => "dbi:mysql:test"
-    Ruport::Config.source :bar, :dsn => "dbi:mysql:test2"
-    assert_equal("dbi:mysql:test",  Ruport::Config.sources[:foo].dsn)
-    assert_equal("dbi:mysql:test2", Ruport::Config.sources[:bar].dsn)
-  end
-
-  def test_simple_interface
-    Ruport.configure do |c|
-      c.source :foo, :dsn => "dbi:odbc:test"
-      c.source :bar, :dsn => "dbi:odbc:test2"
-    end
-    assert_equal("dbi:odbc:test",Ruport::Config.sources[:foo].dsn)
-    assert_equal("dbi:odbc:test2",Ruport::Config.sources[:bar].dsn)
-  end
-    
-
-  def test_logger
-    # We have a logger running now, dont we?
-    assert(Ruport::Config.logger.kind_of?(Logger)) 
-      
-    # And then we change are mind again.  Back logging?
-    Ruport::Config.log_file = "test/unit.log"  
-    assert(Ruport::Config.logger.kind_of?(Logger))
-    
-  end
-
-  def test_debug
-    assert_equal(false, Ruport::Config.debug_mode?)
-    Ruport::Config.debug_mode = true 
-    assert_equal(true, Ruport::Config.debug_mode?)
-    Ruport::Config.debug_mode = false
-    assert_equal(false, Ruport::Config.debug_mode?)
-  end
-  
-  def test_adding_custom_accessors
-    Ruport::Config.my_new_setting = 'blinky'
-    assert_equal('blinky', Ruport::Config.my_new_setting)
-    Ruport::Config.my_new_setting = 'clyde'
-    assert_equal('clyde', Ruport::Config.my_new_setting)
-    
-    Ruport::Config.my_other_new_setting 'inky'
-    assert_equal('inky', Ruport::Config.my_other_new_setting)
-    Ruport::Config.my_other_new_setting 'sue'
-    assert_equal('sue', Ruport::Config.my_other_new_setting)
-  end
-  
-end

data/test/test_format_text.rb

@@ -1,63 +0,0 @@
-require "test/unit"
-require "ruport"
-class TestFormatText < Test::Unit::TestCase
-  
-  def test_basic
-
-    tf = "+-------+\n"
-    
-    a = [[1,2],[3,4]].to_table.to_text
-    assert_equal("#{tf}| 1 | 2 |\n| 3 | 4 |\n#{tf}",a)
-
-    a = [[1,2],[3,4]].to_table(%w[a b]).to_text
-    assert_equal("#{tf}| a | b |\n#{tf}| 1 | 2 |\n| 3 | 4 |\n#{tf}", a)
-    
-  end
-
-
-  def test_centering
-    tf = "+---------+\n" 
-
-    a = [[1,2],[300,4]].to_table
-    assert_equal( "#{tf}|  1  | 2 |\n| 300 | 4 |\n#{tf}",
-                  a.as(:text) { |e| e.layout.alignment = :center })
-
-    tf = "+------------+\n"
-    a.column_names = %w[a bark]     
-    assert_equal("#{tf}|  a  | bark |\n#{tf}|  1  |  2   |\n"+
-                 "| 300 |  4   |\n#{tf}",
-                  a.as(:text) { |e| e.layout.alignment = :center })
-    
-  end
-
-  def test_justified
-    tf = "+----------+\n"
-    a = [[1,'Z'],[300,'BB']].to_table
-    assert_equal "#{tf}|   1 | Z  |\n| 300 | BB |\n#{tf}", a.to_s
-  end
-
-  def test_wrapping  
-    a = [[1,2],[300,4]].to_table.as(:text) { |r|
-      r.layout { |l| l.table_width = 10 }
-    }
-
-    assert_equal("+------->>\n|   1 | >>\n| 300 | >>\n+------->>\n",a)
-  end
-
-
-  def test_make_sure_this_damn_column_names_bug_dies_a_horrible_death!
-    a = [[1,2,3]].to_table.to_text
-    expected = "+-----------+\n"+
-               "| 1 | 2 | 3 |\n"+
-               "+-----------+\n"
-    assert_equal(expected,a)
-
-  end
-
-  def test_raise_error_on_empty_table
-    assert_raise(RuntimeError) { [].to_table.to_text }
-    assert_raise(RuntimeError) { [].to_table(%w[a b c]).to_text }
-  end
-
-  
-end

data/test/test_graph_renderer.rb

@@ -1,97 +0,0 @@
-require "test/unit"
-require "ruport"
-
-begin
-  require "rubygems"
-rescue LoadError
-  nil
-end
-
-class MockGraphPlugin < Ruport::Format::Plugin
-  def prepare_graph 
-    output << "prepare"
-  end
-  def build_graph
-    output << "build"
-  end
-  def finalize_graph
-    output << "finalize"
-  end
-end
-
-Ruport::Renderer::Graph.add_format MockGraphPlugin, :mock
-
-class TestGraphRenderer < Test::Unit::TestCase
-  
-  def test_basics
-    out = Ruport::Renderer::Graph.render_mock do |r|
-      r.layout do |l|
-        assert l.height.kind_of?(Numeric)
-        assert l.width.kind_of?(Numeric)
-        assert_equal :line, l.style
-      end
-    end
-
-    assert_equal("preparebuildfinalize",out)    
-  end
-
-  def test_report_shortcut
-    a = Ruport::Report.new
-    a.extend(Ruport::Report::Graph)
-
-    p = lambda { |e| e.data = [[1,2,3]].to_table(%w[a b c]) }
-
-    b = a.build_graph(&p)
-    c = b.run
-    assert_not_nil b.plugin.output
-
-    assert_equal c, a.render_graph(&p)
-
-  end
-  
-end
-
-
-class TestSVGPlugin < Test::Unit::TestCase
-
-  def test_output
-    assert_not_nil Ruport::Renderer::Graph.render_svg { |r|
-      r.data = [[1,2,3],[4,5,6]].to_table
-    }
-  end
-
-end
-
-class TestXMLSWFPlugin < Test::Unit::TestCase
-
-  def test_output
-  
-    expected = <<-EOS
-<chart>
-  <chart_type>line</chart_type>
-  <chart_data>
-    <row>
-      <null/>
-    </row>
-    <row>
-      <string>Region 0</string>
-      <number>1</number>
-      <number>2</number>
-      <number>3</number>
-    </row>
-    <row>
-      <string>Region 1</string>
-      <number>4</number>
-      <number>5</number>
-      <number>6</number>
-    </row>
-  </chart_data>
-</chart>
-EOS
-    assert_equal expected,
-    Ruport::Renderer::Graph.render_xml { |r|
-      r.data = [[1,2,3],[4,5,6]].to_table
-    }
-  end
-
-end

data/test/test_groupable.rb

@@ -1,56 +0,0 @@
-require "ruport"
-require "test/unit"
-
-class Ruport::Data::Table
-  include Ruport::Data::Groupable
-end
-
-# ticket:96
-class TestGroupable < Test::Unit::TestCase
-  def test_simple
-    a = [[1,2],[3,4],[5,6],[7,8]].to_table(%w[a b])
-    a[0].tag("grp_foo"); a[1].tag("grp_bar");
-    a[2].tag("grp_bar"); a[3].tag("grp_foo");
-
-
-    expected = Ruport::Data::Record.new( [ [[1,2],[7,8]].to_table(%w[a b]),
-                                           [[3,4],[5,6]].to_table(%w[a b]) ], 
-                                           :attributes => %w[foo bar] )
-    assert_equal expected, a.groups
-
-    a[0].tag("grp_bar")
-
-    expected = Ruport::Data::Record.new( [ [[1,2],[7,8]].to_table(%w[a b]),
-                                           [[1,2],[3,4],[5,6]].to_table(%w[a b]) ], 
-                                           :attributes => ["foo","bar"] )
-    assert_equal expected, a.groups
-  end  
-
-  def test_create_group
-    a = [[1,2,3],[4,5,6],[7,8,9]].to_table(%w[a b c]) 
-    expected = Ruport::Data::Record.new( [ [[1,2,3],[7,8,9]].to_table(%w[a b c]),
-                                          [[4,5,6]].to_table(%w[a b c]) ],
-                                           :attributes => %w[starts_odd starts_even])
-    a.create_group("starts_odd") { |r| (r[0] % 2) != 0 }
-    a.create_group(:starts_even) { |r| (r[0] % 2).zero? }
-
-    assert_equal expected, a.groups 
-    assert_equal([[1,2,3],[7,8,9]].to_table(%w[a b c]), a.group("starts_odd"))
-    assert_equal([[1,2,3],[7,8,9]].to_table(%w[a b c]), a.group(:starts_odd)) 
-    assert_equal([[4,5,6]].to_table(%w[a b c]), a.group("starts_even"))
-    
-  end    
-  
-  #--BUG TRAPS-------------------------------------------------------------
-   
-  #Ticket #155
-  def test_ensure_grouping_works_with_nameless_tables
-    a = [[1,2],[3,4],[5,6]].to_table
-    a.create_group("foo") { true }
-    a[1].tag("grp_bar")
-    assert_nothing_raised { a.groups }
-    assert_equal a, a.group("foo")
-    assert_equal [a[1]].to_table, a.group("bar")
-  end
-
-end

data/test/test_mailer.rb

@@ -1,170 +0,0 @@
-require "test/unit"
-require "ruport"
-begin; require "rubygems"; rescue LoadError; nil end
-
-begin
-  require 'mocha'
-  require 'stubba'
-  require 'net/smtp'
-rescue LoadError
-  $stderr.puts "Warning: Mocha not found -- skipping some Mailer tests"
-end
-
-class TestMailer < Test::Unit::TestCase
-
-  def setup
-    @default_opts = {
-      :host => "mail.example.com", 
-      :address => "sue@example.com", 
-      :user => "inky",
-      :password => "chunky"
-    }
-
-    @other_opts = {
-      :host => "moremail.example.com",
-      :address => "clyde@example.com",
-      :user => "blinky",
-      :password => "bacon"
-    }
-
-    Ruport::Config.mailer :default, @default_opts
-    Ruport::Config.mailer :other, @other_opts
-
-    @default_mailer = Ruport::Mailer.new
-    @other_mailer = Ruport::Mailer.new :other 
-  end
-    
-  def assert_mailer_equal(expected, mailer)
-    assert_equal expected[:host], mailer.instance_variable_get(:@host)
-    assert_equal expected[:address], mailer.instance_variable_get(:@address)
-    assert_equal expected[:user], mailer.instance_variable_get(:@user)
-    assert_equal expected[:password], mailer.instance_variable_get(:@password)
-  end
-  
-  def test_default_constructor    
-    assert_mailer_equal @default_opts, @default_mailer
-  end
-  
-  def test_constructor_with_mailer_label
-    assert_mailer_equal @other_opts, @other_mailer
-  end
-
-  def test_constructor_without_mailer
-    Ruport::Config.mailers[:default] = nil
-    assert_raise(RuntimeError) { Ruport::Mailer.new }
-  end
- 
-  def test_select_mailer
-    mailer = Ruport::Mailer.new :default
-    assert_mailer_equal @default_opts, mailer
-
-    mailer.send(:select_mailer, :other)
-    assert_mailer_equal @other_opts, mailer
-  end
-
-  def test_to
-    @default_mailer.instance_eval "@mail.to = ['foo@bar.com']"
-    assert_equal ['foo@bar.com'], @default_mailer.to
-  end
-
-  def test_to_equals
-    @default_mailer.to = ['foo@bar.com']
-    assert_equal ['foo@bar.com'], @default_mailer.to    
-  end
-
-  def test_from
-    @default_mailer.instance_eval "@mail.from = ['foo@bar.com']"
-    assert_equal ['foo@bar.com'], @default_mailer.from
-  end
-
-  def test_from_equals
-    @default_mailer.from = ['foo@bar.com']
-    assert_equal ['foo@bar.com'], @default_mailer.from
-  end
-
-  def test_subject
-    @default_mailer.instance_eval "@mail.subject = ['RuportDay!']"
-    assert_equal ['RuportDay!'], @default_mailer.subject
-  end
-
-  def test_subject_equals
-    @default_mailer.subject = ['RuportDay!']
-    assert_equal ['RuportDay!'], @default_mailer.subject
-  end
-
-  def test_send_mail_with_default
-    return unless Object.const_defined? :Mocha
-    setup_mock_mailer(1)
-    assert_equal "250 ok",
-      @default_mailer.deliver(:to      => "clyde@example.com",
-                              :from    => "sue@example.com",
-                              :subject => "Hello",
-                              :text    => "This is a test.")
-  end
-
-  def test_send_mail_with_other
-    return unless Object.const_defined? :Mocha
-    setup_mock_mailer(1, @other_mailer)
-    assert_equal "250 ok",
-      @other_mailer.deliver(:to      => "sue@example.com",
-                            :from    => "clyde@example.com",
-                            :subject => "Hello",
-                            :text    => "This is a test.")
-  end
-
-  def test_send_mail_without_to
-    return unless Object.const_defined? :Mocha
-    setup_mock_mailer(1)
-    assert_raise(Net::SMTPSyntaxError) {
-      @default_mailer.deliver(:from    => "sue@example.com",
-                              :subject => "Hello",
-                              :text    => "This is a test.")
-    }
-  end
-
-  def test_send_html_mail
-    return unless Object.const_defined? :Mocha
-    setup_mock_mailer(1)
-    assert_equal "250 ok",
-      @default_mailer.deliver(:to      => "clyde@example.com",
-                              :from    => "sue@example.com",
-                              :subject => "Hello",
-                              :html    => "<p>This is a test.</p>")
-  end
-
-  def test_send_mail_with_attachment
-    return unless Object.const_defined? :Mocha
-    setup_mock_mailer(1)
-    @default_mailer.attach 'test/samples/data.csv'
-    assert_equal "250 ok",
-      @default_mailer.deliver(:to      => "clyde@example.com",
-                              :from    => "sue@example.com",
-                              :subject => "Hello",
-                              :text    => "This is a test.")
-  end
-  
-  private
-  
-  def setup_mock_mailer(count, mailer=@default_mailer)
-    host      = mailer.instance_variable_get(:@host)
-    port      = mailer.instance_variable_get(:@port)
-    user      = mailer.instance_variable_get(:@user)
-    password  = mailer.instance_variable_get(:@password)
-    auth      = mailer.instance_variable_get(:@auth)
-    
-    @smtp     = mock('smtp')
-    
-    Net::SMTP.expects(:start).
-      with(host,port,host,user,password,auth).
-      yields(@smtp).
-      returns("250 ok").times(count)
-    @smtp.stubs(:send_message).
-      with {|*params| !params[2].nil? }.
-      returns("250 ok")
-    @smtp.stubs(:send_message).
-      with {|*params| params[2].nil? }.
-      raises(Net::SMTPSyntaxError)
-  end
-
-end
-