ruport-util 0.6.0 → 0.7.0

data/test/test_format_ods.rb

@@ -0,0 +1,46 @@
+require 'test/helper'
+
+testcase_requires 'hpricot'
+
+describe 'OSD Formatter' do
+  before :all do
+    @csv = "first col,second col,third col\n" +
+           "first row,cell 1,cell 2\n"        +
+           "second row,cell 3,cell 4\n"       +
+           "third row,special >,special <\n"  +
+           "fourth row,,after empty\n"        +
+           "\n"                               +
+           "seventh row,nothing,more\n"
+    @table = Table(:string => @csv)
+    zipfile = @table.to_ods(:tempfile => true)
+    zip = Zip::ZipFile.open(zipfile.path)
+    @content = zip.read('content.xml')
+    zip.close
+    @doc = Hpricot(@content)
+    @rows = (@doc/'table:table-row')
+  end
+
+  it 'should have content' do
+    @content.should_not be_nil
+  end
+
+  it 'should have all rows' do
+    @rows.should have(7).rows
+  end
+
+  it 'should have the header' do
+    headers = (@rows.first/'text:p').map{|t| t.inner_html}
+    headers.should == @table.column_names
+  end
+
+  it 'should have the two rows with data' do
+    @rows[1..2].zip(@table.data).each do |h_row, r_row|
+      (h_row/'text:p').map{ |t| t.inner_html }.should == r_row.to_a
+    end
+  end
+
+  it 'should escape HTML entities' do
+    (@rows[3]/'text:p').map{|e| e.inner_html}.
+      should == %w[third\ row special\ &gt; special\ &lt;]
+  end
+end

data/test/test_graph_renderer.rb

@@ -1,5 +1,6 @@
-require "test/init"
-require "ruport/util/graph"
+require 'test/helper'
+
+quiet { testcase_requires 'scruffy' }
 
 class MockGraphPlugin < Ruport::Formatter
   renders :mock, :for => Ruport::Renderer::Graph
@@ -14,36 +15,27 @@ class MockGraphPlugin < Ruport::Formatter
   end
 end
 
+describe 'Graph Renderer' do
+  before :all do
+    @graph = Ruport::Renderer::Graph
+    @data = Ruport::Graph(:data => [[1,2,3],[4,5,6]])
+  end
 
-class TestGraphRenderer < Test::Unit::TestCase
-  
-  def test_basics
-    out = Ruport::Renderer::Graph.render_mock do |r|
+  it 'should render' do
+    out = @graph.render_mock do |r|
       r.options do |l|
-        assert_equal :line, l.style
+        l.style.should == :line
       end
     end
 
-    assert_equal("preparebuildfinalize",out)    
+    out.should == 'preparebuildfinalize'
   end
 
-end
-
-
-class TestSVGPlugin < Test::Unit::TestCase
-
-  def test_output
-    assert_not_nil Ruport::Renderer::Graph.render_svg { |r|
-      r.data = Ruport::Graph(:data => [[1,2,3],[4,5,6]])
-    }
+  it 'should render SVG' do
+    @graph.render_svg{|r| r.data = @data}.should_not be_nil
   end
 
-end
-
-class TestXMLSWFPlugin < Test::Unit::TestCase
-
-  def test_output
-  
+  it 'should render XMLSWF via block' do
     expected = <<-EOS
 <chart>
   <chart_type>line</chart_type>
@@ -66,11 +58,11 @@ class TestXMLSWFPlugin < Test::Unit::TestCase
   </chart_data>
 </chart>
 EOS
-    assert_equal expected,
-    Ruport::Renderer::Graph.render_xml_swf { |r|
-      r.data = Ruport::Graph(:data => [[1,2,3],[4,5,6]])  
-    } 
-    
+
+    @graph.render_xml_swf{|r| r.data = @data}.should == expected
+  end
+
+  it 'should render XMLSWF via add_line' do
     expected = <<-EOS
 <chart>
   <chart_type>line</chart_type>
@@ -98,8 +90,6 @@ EOS
   graph.add_line [1,2,3], :name => "Alpha"
   graph.add_line [4,5,6], :name => "Beta"
   
-  assert_equal expected, graph.to_xml_swf
-    
+  graph.to_xml_swf.should == expected
   end
-
 end

data/test/test_invoice.rb

@@ -1,31 +1,33 @@
-require "test/init"
-require "ruport/util"
+require 'test/helper'
 
-class TestInvoice < Test::Unit::TestCase
+describe 'Invoice' do
+  before :all do
+    @invoice = Ruport::Renderer::Invoice
+    @data = Table(%w[a b c]) << [1,2,3]
+  end
+
+  it 'should raise if the required options are not set' do
+    lambda{ @invoice.render_pdf }.
+      should raise_error(Ruport::Renderer::RequiredOptionNotSet)
+  end
+
+  it "shouldn't raise if options are given correct in hash form" do
+    lambda do
+      @invoice.render_pdf :data => @data,
+        :customer_info => 'blah', :company_info => 'also blah',
+        :order_info => 'Incredibly Blah', :comments => 'Super Blah'
+    end.should_not raise_error
+  end
 
-  def test_required_options         
-    assert_raises(Ruport::Renderer::RequiredOptionNotSet) { 
-      Ruport::Renderer::Invoice.render_pdf 
-    }
-    
-    #hash form
-    assert_nothing_raised {
-      Ruport::Renderer::Invoice.render_pdf :data => Table(%w[a b c]) << [1,2,3],
-         :customer_info => "blah", :company_info => "also blah",
-         :order_info => "Incredibly Blah", :comments => "Super Blah"
-    }         
-    
-    #block form
-    assert_nothing_raised {
-      Ruport::Renderer::Invoice.render_pdf do |r|
-         r.data = Table(%w[a b c]) << [1,2,3]
-         r.customer_info = "blah"
-         r.company_info  = "also blah"
-         r.order_info    = "Incredibly Blah"  
-         r.comments      = "Super blah"
-      end     
-    }
+  it "shouldn't raise if options are given correct in block form" do
+    lambda do
+      @invoice.render_pdf do |r|
+        r.customer_info = 'blah'
+        r.company_info  = 'also blah'
+        r.order_info    = 'Incredibly Blah'
+        r.comments      = 'Super Blah'
+        r.data          = @data
+      end
+    end.should_not raise_error
   end
-  
-  
-end  
+end

data/test/test_mailer.rb

@@ -1,206 +1,163 @@
-require "test/unit"
-begin; require "rubygems"; rescue LoadError; nil end
-require "ruport"
-require "ruport/util/mailer"
-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
+require 'test/helper'
+require 'net/smtp'
 
-  def setup
+describe 'Mailer' do
+  before :all do
     @default_opts = {
-      :host => "mail.example.com", 
-      :address => "sue@example.com", 
-      :user => "inky",
+      :user     => "inky",
+      :host     => "mail.example.com", 
+      :address  => "sue@example.com", 
       :password => "chunky"
     }
 
     @other_opts = {
-      :host => "moremail.example.com",
-      :address => "clyde@example.com",
-      :user => "blinky",
+      :user     => "blinky",
+      :host     => "moremail.example.com",
+      :address  => "clyde@example.com",
       :password => "bacon"
     }
 
-    Ruport::Mailer.add_mailer :default, @default_opts
-    Ruport::Mailer.add_mailer :other, @other_opts
+    @mailer = Ruport::Mailer
 
-    @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
+    @mailer.add_mailer :default, @default_opts
+    @mailer.add_mailer :other, @other_opts
 
-  def test_send_to
-     return unless Object.const_defined? :Mocha
-     setup_mock_report_mailer
-     @report = Ruport::Report.new
-     assert_equal "250 ok", @report.send_to("clyde@example.com") { |mail|
-       mail.subject = "Test Report"
-       mail.text = "Test"
-     }
-   end
+    @default_mailer = @mailer.new :default
+    @other_mailer = @mailer.new :other
 
-  def test_mail_defaults
-    assert_equal( Ruport::Mailer.mailers[:default], 
-                  Ruport::Mailer.default_mailer)
+    @mail_fields = { :to      => 'clyde@example.com',
+                     :from    => 'sue@example.com',
+                     :subject => 'Hello',
+                     :text    => 'This is a test' }
   end
 
+  def values_for(mailer, *keys)
+    keys = keys.flatten.map{|k| k.to_s}
+    keys.map{|k| mailer.instance_variable_get("@#{k}") }
+  end
 
-  
-  def test_default_constructor    
-    assert_mailer_equal @default_opts, @default_mailer
+  def check(mailer, expected)
+    keys = [:host, :address, :user, :password]
+    values = values_for(mailer, *keys)
+    values.should == expected.values_at(*keys)
   end
-  
-  def test_constructor_with_mailer_label
-    assert_mailer_equal @other_opts, @other_mailer
+
+  def mock_report_mailer
+    @smtp = mock('SMTP')
+    @smtp.stub!(:send_message).and_return('250 ok')
+    Net::SMTP.should_receive(:start).and_return("250 ok")
   end
 
-  def test_constructor_without_mailer
-    Ruport::Mailer.mailers[:default] = nil
-    assert_raise(RuntimeError) { Ruport::Mailer.new }
+  def mock_mailer(count, mailer = @default_mailer)
+    values = values_for(mailer, :host, :port, :host, :user, :password, :auth)
+
+    @smtp = mock('SMTP')
+
+    Net::SMTP.should_receive(:start).
+      with(*values).
+      exactly(count).times.
+      and_yield(@smtp)
+    @smtp.should_receive(:send_message).
+      with( an_instance_of(String), 
+            an_instance_of(String), 
+            an_instance_of(String) ).any_number_of_times.
+      and_return('250 ok')
+    @smtp.should_receive(:send_message).
+      with(an_instance_of(String),an_instance_of(String), nil).any_number_of_times.
+      and_raise(Net::SMTPSyntaxError)
   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
+  it 'should have default mailer' do
+    @mailer.mailers[:default].should == @mailer.default_mailer
   end
 
-  def test_mailer_config_errors
+  it 'should have equal options inside and outside of default mailer' do
+    check @default_mailer, @default_opts
+  end
 
-    assert_raise(Ruport::Mailer::InvalidMailerConfigurationError) {
-      Ruport::Mailer.add_mailer :bar, :user => :foo, :address => "foo@bar.com"
-    }
-    assert_nothing_raised { Ruport::Mailer.add_mailer :bar, :host => "localhost" }
+  it 'should have equal options inside and outside of other mailer' do
+    check @other_mailer, @other_opts
   end
 
+  it 'should raise if no default mailer is set' do
+    default = @mailer.mailers.delete :default
 
+    lambda{ @mailer.new }.
+      should raise_error(RuntimeError, 'you need to specify a mailer to use')
 
-  def test_to
-    @default_mailer.instance_eval "@mail.to = ['foo@bar.com']"
-    assert_equal ['foo@bar.com'], @default_mailer.to
+    @mailer.mailers[:default] = default
   end
 
-  def test_to_equals
-    @default_mailer.to = ['foo@bar.com']
-    assert_equal ['foo@bar.com'], @default_mailer.to    
-  end
+  it 'should raise if configuration is invalid' do
+    lambda{ @mailer.add_mailer :bar, :user => :foo, :address => 'foo@bar.com' }.
+      should raise_error(Ruport::Mailer::InvalidMailerConfigurationError)
 
-  def test_from
-    @default_mailer.instance_eval "@mail.from = ['foo@bar.com']"
-    assert_equal ['foo@bar.com'], @default_mailer.from
+    lambda{ @mailer.add_mailer :bar, :host => 'localhost' }.
+      should_not raise_error
   end
 
-  def test_from_equals
-    @default_mailer.from = ['foo@bar.com']
-    assert_equal ['foo@bar.com'], @default_mailer.from
+  it 'should send emails with default' do
+    mock_mailer 1
+    @default_mailer.deliver(@mail_fields).should == '250 ok'
   end
 
-  def test_subject
-    @default_mailer.instance_eval "@mail.subject = ['RuportDay!']"
-    assert_equal ['RuportDay!'], @default_mailer.subject
+  it 'should send emails with other default' do
+    mock_mailer 1, @other_mailer
+    @other_mailer.deliver(@mail_fields).should == '250 ok'
   end
 
-  def test_subject_equals
-    @default_mailer.subject = ['RuportDay!']
-    assert_equal ['RuportDay!'], @default_mailer.subject
+  it 'should send mail without to field' do
+    mock_mailer 1
+    hash = @mail_fields.dup
+    hash.delete :to
+    lambda{ @default_mailer.deliver(hash) }.
+      should raise_error(Net::SMTPSyntaxError)
   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.")
+  it 'should send mail with HTML' do
+    mock_mailer 1
+    hash = @mail_fields.dup
+    hash.delete(:text)
+    hash[:html] = '<p>This is a test.</p>'
+    @default_mailer.deliver(hash).should == '250 ok'
   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.")
+  it 'should send mail with attachment' do
+    mock_mailer 1
+    @default_mailer.attach 'test/samples/data.csv'
+    @default_mailer.deliver(@mail_fields).should == '250 ok'
   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.")
-    }
+  it 'should have information about the mail' do
+    dfm = @default_mailer
+
+    { :to      => ['foo@bar.com'],
+      :from    => ['foo@bar.com'],
+      :subject => ['RuportDay!']
+    }.each do |meth, value|
+      assign_meth = "#{meth}="
+
+      dfm.instance_eval{ @mail.send(assign_meth, value) }
+      dfm.send(meth).should == value
+
+      dfm.send(assign_meth, value)
+      dfm.send(meth).should == value
+    end
   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>")
+  it 'should be able to select a mailer' do
+    mailer = @mailer.new(:default)
+    check mailer, @default_opts
+    mailer.send(:select_mailer, :other)
+    check mailer, @other_opts
   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
-  
-  def setup_mock_report_mailer
-     @smtp     = mock('smtp')
- 
-     Net::SMTP.expects(:start).
-       yields(@smtp).
-       returns("250 ok").at_least_once
-     @smtp.stubs(:send_message).
-       returns("250 ok")
-   end
+  it 'should send reports with default mailer' do
+    report = Ruport::Report.new
+    mock_report_mailer
+    report.send_to(@other_opts[:address]){|mail|
+      mail.subject = 'Test Report'
+      mail.text = 'Test'
+    }.should == '250 ok'
+  end
 end
-