solaris-patch 1.0.2 → 1.0.3

data/lib/solaris/util.rb

@@ -1,4 +1,3 @@
-
 module Solaris
 
   # Utility module.
@@ -34,28 +33,28 @@ module Solaris
       end
       # If we got a filename then open now before attempting download
       raise ArgumentError, 'Cannot specify both :to_dir and :to_file' if filename && dirname
-      filename = File.join( dirname, File.basename( url ) ) if dirname
+      filename = File.join(dirname, File.basename(url)) if dirname
       begin
-        file = File.open( filename, 'w' ) if filename
+        file = File.open(filename, 'w') if filename
         # Set agent authentication parameters
         if opts[:user] && opts[:password]
-          agent.basic_auth( opts[:user], opts[:password] )
+          agent.basic_auth(opts[:user], opts[:password])
         elsif opts[:user]
           raise ArgumentError, 'Cannot authenticate without a password'
         elsif opts[:password]
           raise ArgumentError, 'Cannot authenticate without a username'
         end
         # Download file and save as required
-        page = agent.get( url )
+        page = agent.get(url)
         if file
-          file.write( page.body )
+          file.write(page.body)
           file.close
         end
       rescue => exception
         # Try to remove incomplete file on error
         if file
           begin file.close ; rescue ; end
-          begin File.unlink( file ) ; rescue ; end
+          begin File.unlink(file) ; rescue ; end
         end
         raise exception # rethrow original exception
       end
@@ -65,4 +64,3 @@ module Solaris
   end # Util
 
 end # Solaris
-

data/test/test_patch.rb

@@ -1,4 +1,3 @@
-
 require 'test/unit'
 require 'solaris/patch'
 
@@ -6,83 +5,83 @@ require 'solaris/patch'
 class TestPatch < Test::Unit::TestCase #:nodoc:
 
   def test_new_string_major_only
-    patch = Solaris::Patch.new( '123456' )
-    assert_equal( 123456, patch.major )
-    assert_nil( patch.minor )
+    patch = Solaris::Patch.new('123456')
+    assert_equal(123456, patch.major)
+    assert_nil(patch.minor)
   end
 
   def test_new_int_major_only
-    patch = Solaris::Patch.new( 123456 )
-    assert_equal( 123456, patch.major )
-    assert_nil( patch.minor )
+    patch = Solaris::Patch.new(123456)
+    assert_equal(123456, patch.major)
+    assert_nil(patch.minor)
   end
 
   def test_new_string_minor_only
-    assert_raise( ArgumentError ) do
-      Solaris::Patch.new( '-78' )
+    assert_raise(ArgumentError) do
+      Solaris::Patch.new('-78')
     end
   end
 
   def test_new_string_major_and_minor
-    patch = Solaris::Patch.new( '123456-78' )
-    assert_equal( 123456, patch.major )
-    assert_equal( 78, patch.minor )
+    patch = Solaris::Patch.new('123456-78')
+    assert_equal(123456, patch.major)
+    assert_equal(78, patch.minor)
   end
 
   def test_new_int_major_and_minor
-    patch = Solaris::Patch.new( 123456, 78 )
-    assert_equal( 123456, patch.major )
-    assert_equal( 78, patch.minor )
+    patch = Solaris::Patch.new(123456, 78)
+    assert_equal(123456, patch.major)
+    assert_equal(78, patch.minor)
   end
 
   def test_new_no_args
     patch = Solaris::Patch.new()
-    assert_nil( patch.major )
-    assert_nil( patch.minor )
+    assert_nil(patch.major)
+    assert_nil(patch.minor)
   end
 
   def test_new_valid_opts
-    patch = Solaris::Patch.new( '123456-78' )
-    assert_equal( 123456, patch.major )
-    assert_equal( 78, patch.minor )
+    patch = Solaris::Patch.new('123456-78')
+    assert_equal(123456, patch.major)
+    assert_equal(78, patch.minor)
   end
 
   def test_to_s
-    patch = Solaris::Patch.new( '123456-78' )
-    assert_equal( '123456-78', patch.to_s )
+    patch = Solaris::Patch.new('123456-78')
+    assert_equal('123456-78', patch.to_s)
   end
 
   def test_to_s_padding
-    patch = Solaris::Patch.new( '123456-7' )
-    assert_equal( '123456-07', patch.to_s )
+    patch = Solaris::Patch.new('123456-7')
+    assert_equal('123456-07', patch.to_s)
   end
 
   def test_to_s_major_only
-    patch = Solaris::Patch.new( 123456 )
-    assert_equal( '123456', patch.to_s )
+    patch = Solaris::Patch.new(123456)
+    assert_equal('123456', patch.to_s)
   end
 
   def test_comparison
-    assert( Solaris::Patch.new( '123456-78' ) == Solaris::Patch.new( '123456-78' ) )
-    assert( Solaris::Patch.new( '123456-1' ) == Solaris::Patch.new( '123456-01' ) )
-    assert( Solaris::Patch.new( '123456' ) == Solaris::Patch.new( '123456' ) )
-    assert( Solaris::Patch.new( '123456-78' ) < Solaris::Patch.new( '123456-79' ) )
-    assert( Solaris::Patch.new( '123456-78' ) < Solaris::Patch.new( '123457-78' ) )
-    assert( Solaris::Patch.new( '123456-1' ) < Solaris::Patch.new( '123456-10' ) )
+    assert(Solaris::Patch.new('123456-78') == Solaris::Patch.new('123456-78'))
+    assert(Solaris::Patch.new('123456-1') == Solaris::Patch.new('123456-01'))
+    assert(Solaris::Patch.new('123456') == Solaris::Patch.new('123456'))
+    assert(Solaris::Patch.new('123456-78') < Solaris::Patch.new('123456-79'))
+    assert(Solaris::Patch.new('123456-78') < Solaris::Patch.new('123457-78'))
+    assert(Solaris::Patch.new('123456-1') < Solaris::Patch.new('123456-10'))
   end
 
   def test_download_requires_major
     patch = Solaris::Patch.new
     patch.minor = 1
-    assert_raise( ArgumentError ) { patch.download_patch! }
-    assert_raise( ArgumentError ) { patch.download_readme! }
+    assert_raise(ArgumentError) { patch.download_patch! }
+    assert_raise(ArgumentError) { patch.download_readme! }
   end
 
   def test_download_requires_minor
     patch = Solaris::Patch.new
     patch.major = 123456
-    assert_raise( ArgumentError ) { patch.download_patch! }
-    assert_raise( ArgumentError ) { patch.download_readme! }
+    assert_raise(ArgumentError) { patch.download_patch! }
+    assert_raise(ArgumentError) { patch.download_readme! }
   end
 
   def test_download!
@@ -90,11 +89,10 @@ class TestPatch < Test::Unit::TestCase #:nodoc:
   end
 
   def test_pad_minor
-    assert_equal( '00', Solaris::Patch.pad_minor( 0 ) )
-    assert_equal( '01', Solaris::Patch.pad_minor( 1 ) )
-    assert_equal( '12', Solaris::Patch.pad_minor( 12 ) )
-    assert_equal( '123', Solaris::Patch.pad_minor( 123 ) )
+    assert_equal('00', Solaris::Patch.pad_minor(0))
+    assert_equal('01', Solaris::Patch.pad_minor(1))
+    assert_equal('12', Solaris::Patch.pad_minor(12))
+    assert_equal('123', Solaris::Patch.pad_minor(123))
   end
 
 end
-

data/test/test_patchdiag.rb

@@ -1,4 +1,3 @@
-
 require 'test/unit'
 require 'stringio'
 require 'solaris/patchdiag'
@@ -77,9 +76,9 @@ class TestPatchdiag < Test::Unit::TestCase #:nodoc:
 654322|01|Jan/01/00| | |O|  |Unbundled|||Obsoleted by: 654321-05
 115302|01|Jul/08/03| | |O| B|Unbundled|||WITHDRAWN PATCH Obsoleted by: 115302-02 Hardware/PROM: CP2060/CP20
 EOF
-    @patchdiag_fileish = StringIO.new( @patchdiag_string )
+    @patchdiag_fileish = StringIO.new(@patchdiag_string)
     @patchdiag_size = 56
-    @patchdiag = Solaris::Patchdiag.open( @patchdiag_fileish )
+    @patchdiag = Solaris::Patchdiag.open(@patchdiag_fileish)
   end
 
   def teardown
@@ -91,202 +90,243 @@ EOF
   end
 
   def test_new_by_fileish
-    assert_equal( @patchdiag_size, @patchdiag.entries.size )
+    assert_equal(@patchdiag_size, @patchdiag.entries.size)
   end
 
   def test_new_by_filename
-    temp = Tempfile.new( 'test_patchdiag' )
+    temp = Tempfile.new('test_patchdiag')
     path = temp.path
-    temp.write( @patchdiag_fileish )
+    temp.write(@patchdiag_fileish)
     temp.close
-    patchdiag = Solaris::Patchdiag.new( path )
-    File.unlink( path )
-    assert_equal( @patchdiag_size, @patchdiag.entries.size )
+    patchdiag = Solaris::Patchdiag.new(path)
+    File.unlink(path)
+    assert_equal(@patchdiag_size, @patchdiag.entries.size)
   end
 
   def test_new_empty_file
-    if File.exists?( @empty_file )
-      patchdiag = Solaris::Patchdiag.new( @empty_file )   
-      assert_equal( 0, patchdiag.entries.size )
+    if File.exists?(@empty_file)
+      patchdiag = Solaris::Patchdiag.new(@empty_file)
+      assert_equal(0, patchdiag.entries.size)
     end
   end
 
   def test_no_tailing_newline
     s = StringIO.new('115302|01|Jul/08/03| | |O| B|Unbundled|||blah blah')
-    assert_equal( 1, Solaris::Patchdiag.new( s ).entries.size )
+    assert_equal(1, Solaris::Patchdiag.new(s).entries.size)
   end
 
   def test_clone
     @cloned = @patchdiag.clone
-    assert_equal( @patchdiag.class, @cloned.class )
-    assert_equal( @patchdiag.entries.size, @cloned.entries.size )
-    assert_equal( @patchdiag.entries.first, @cloned.entries.first )
-    assert_not_equal( @patchdiag.object_id, @cloned.object_id )
-    @patchdiag.entries.zip( @cloned.entries ).each do |x,y|
-      assert_not_equal( x.object_id, y.object_id )
+    assert_equal(@patchdiag.class, @cloned.class)
+    assert_equal(@patchdiag.entries.size, @cloned.entries.size)
+    assert_equal(@patchdiag.entries.first, @cloned.entries.first)
+    assert_not_equal(@patchdiag.object_id, @cloned.object_id)
+    @patchdiag.entries.zip(@cloned.entries).each do |x,y|
+      assert_not_equal(x.object_id, y.object_id)
     end
   end
 
   def test_entries
-    assert_equal( @patchdiag_size, @patchdiag.entries.size )
+    assert_equal(@patchdiag_size, @patchdiag.entries.size)
   end
 
   def test_sort_by_date_order_ascending
-    all = @patchdiag.sort_by( &:date )
+    all = @patchdiag.sort_by(&:date)
     first = all.first.patch # oldest
     last = all.last.patch # newest
-    assert_equal( Solaris::Patch.new( '100386-01' ), first )
-    assert_equal( Solaris::Patch.new( '146443-01' ), last )
+    assert_equal(Solaris::Patch.new('100386-01'), first)
+    assert_equal(Solaris::Patch.new('146443-01'), last)
   end
 
   def test_sort_by_patch_order_ascending
     all = @patchdiag.sort
     first = all.first.patch # smallest
     last = all.last.patch # largest
-    assert_equal( Solaris::Patch.new( '800054-01' ), last )
-    assert_equal( Solaris::Patch.new( '100287-05' ), first )
+    assert_equal(Solaris::Patch.new('800054-01'), last)
+    assert_equal(Solaris::Patch.new('100287-05'), first)
   end
 
   def test_open_block
-    ret = Solaris::Patchdiag.open( @patchdiag_fileish ) do |patchdiag|
-      assert_equal( Solaris::Patchdiag, patchdiag.class )
+    ret = Solaris::Patchdiag.open(@patchdiag_fileish) do |patchdiag|
+      assert_equal(Solaris::Patchdiag, patchdiag.class)
       :return_code
     end
-    assert_equal( :return_code, ret )
+    assert_equal(:return_code, ret)
   end
 
   def test_open_return
-    assert_equal( Solaris::Patchdiag, @patchdiag.class )
+    assert_equal(Solaris::Patchdiag, @patchdiag.class)
   end
 
   def test_bad
-    entry = @patchdiag.latest( '115302' )
-    assert_equal( true, entry.bad? )
-    entry = @patchdiag.latest( '654321-01' )
-    assert_equal( false, entry.bad? )
+    entry = @patchdiag.latest('115302')
+    assert_equal(true, entry.bad?)
+    entry = @patchdiag.latest('654321-01')
+    assert_equal(false, entry.bad?)
   end
 
   def test_recommended
-    entry = @patchdiag.latest( '146279-01' )
-    assert_equal( true, entry.recommended? )
-    entry = @patchdiag.latest( '654321-01' )
-    assert_equal( false, entry.recommended? )
+    entry = @patchdiag.latest('146279-01')
+    assert_equal(true, entry.recommended?)
+    entry = @patchdiag.latest('654321-01')
+    assert_equal(false, entry.recommended?)
   end
 
   def test_security
-    entry = @patchdiag.latest( '146279-01' )
-    assert_equal( true, entry.security? )
-    entry = @patchdiag.latest( '654321-01' )
-    assert_equal( false, entry.security? )
+    entry = @patchdiag.latest('146279-01')
+    assert_equal(true, entry.security?)
+    entry = @patchdiag.latest('654321-01')
+    assert_equal(false, entry.security?)
   end
 
   def test_obsolete
-    entry = @patchdiag.latest( '115302-01' )
-    assert_equal( true, entry.obsolete? )
-    entry = @patchdiag.latest( '100287-05' )
-    assert_equal( false, entry.obsolete? )
+    entry = @patchdiag.latest('115302-01')
+    assert_equal(true, entry.obsolete?)
+    entry = @patchdiag.latest('100287-05')
+    assert_equal(false, entry.obsolete?)
+  end
+
+  def test_date
+    assert_equal(2011, @patchdiag.date.year)
+    assert_equal(2, @patchdiag.date.month)
+    assert_equal(10, @patchdiag.date.day)
+  end
+
+  # Some old patchdiag.xref (eg Sep/24/08) contain extraneous HTML <PRE> tags.
+  def test_pre
+    pd_s = <<-EOF
+<PRE>
+## PATCHDIAG TOOL CROSS-REFERENCE FILE AS OF Sep/24/08 ##
+##
+## Please note that certain patches which are listed in
+## Sun's Quick Reference Section or other patch reference
+## files are not publicly available, but instead are
+## available only to customers of Sun Microsystems who
+## have purchased an appropriate support services contract.
+## For more information about Sun support services contracts
+## visit www.sun.com/service
+100287|05|Oct/31/91| | | |  |Unbundled|||PC-NFS 3.5c: Jumbo patch (updated PRT.COM to v3.5c)
+100323|05|Feb/11/92| | | |  |Unbundled|||PC-NFS Advanced Telnet: bug fixes, National Character Set support
+100386|01|Sep/20/91| | | |  |Unbundled|||PC-NFS Programmer's Toolkit/2.0: Runtime modules
+139099|01|Sep/05/08|R|S| |  |10|sparc;|SUNWgtar:11.10.0,REV=2005.01.08.05.16;SUNWgtarS:11.10.0,REV=2005.01.08.05.16;SUNWsfman:11.10.0,REV=2005.01.08.05.16;|SunOS 5.10: gtar patch
+139100|01|Sep/05/08|R|S| |  |10_x86|i386;|SUNWgtar:11.10.0,REV=2005.01.08.01.09;SUNWgtarS:11.10.0,REV=2005.01.08.01.09;SUNWsfman:11.10.0,REV=2005.01.08.01.09;|SunOS 5.10_x86: gtar patch
+800054|01|Mar/16/01| | |O|  |Unbundled|||Obsoleted by: 111346-01 Hardware/PROM: Sun Fire 3800/4800/4810/680
+</PRE>
+EOF
+    pd = Solaris::Patchdiag.new(StringIO.new(pd_s))
+    assert_equal(2008, pd.date.year)
+    assert_equal(9, pd.date.month)
+    assert_equal(24, pd.date.day)
+    assert_equal(pd_s, pd.to_s)
   end
 
   def test_find
-    assert_equal( [], @patchdiag.find( 123456 ) )
-    assert_equal( [], @patchdiag.find( '123456' ) )
-    assert_equal( [], @patchdiag.find( '123456-78' ) )
-    assert_equal( [], @patchdiag.find( Solaris::Patch.new( 123456 ) ) )
-    assert_equal( [], @patchdiag.find( Solaris::Patch.new( '123456' ) ) )
-    assert_equal( [], @patchdiag.find( Solaris::Patch.new( '123456-78' ) ) )
-    assert_equal( [], @patchdiag.find( '100791-01' ) )
-    assert_equal( [], @patchdiag.find( Solaris::Patch.new( '100791-01' ) ) )
-    assert_equal( '100791-04', @patchdiag.find( 100791 ).first.patch.to_s )
-    assert_equal( '100791-04', @patchdiag.find( '100791' ).first.patch.to_s )
-    assert_equal( '100791-04', @patchdiag.find( '100791-04' ).first.patch.to_s )
-    assert_equal( '100791-04', @patchdiag.find( Solaris::Patch.new( 100791) ).first.patch.to_s )
-    assert_equal( '100791-04', @patchdiag.find( Solaris::Patch.new( '100791') ).first.patch.to_s )
-    assert_equal( '100791-04', @patchdiag.find( Solaris::Patch.new( '100791-04') ).first.patch.to_s )
+    assert_equal([], @patchdiag.find(123456))
+    assert_equal([], @patchdiag.find('123456'))
+    assert_equal([], @patchdiag.find('123456-78'))
+    assert_equal([], @patchdiag.find(Solaris::Patch.new(123456)))
+    assert_equal([], @patchdiag.find(Solaris::Patch.new('123456')))
+    assert_equal([], @patchdiag.find(Solaris::Patch.new('123456-78')))
+    assert_equal([], @patchdiag.find('100791-01'))
+    assert_equal([], @patchdiag.find(Solaris::Patch.new('100791-01')))
+    assert_equal('100791-04', @patchdiag.find(100791).first.patch.to_s)
+    assert_equal('100791-04', @patchdiag.find('100791').first.patch.to_s)
+    assert_equal('100791-04', @patchdiag.find('100791-04').first.patch.to_s)
+    assert_equal('100791-04', @patchdiag.find(Solaris::Patch.new(100791)).first.patch.to_s)
+    assert_equal('100791-04', @patchdiag.find(Solaris::Patch.new('100791')).first.patch.to_s)
+    assert_equal('100791-04', @patchdiag.find(Solaris::Patch.new('100791-04')).first.patch.to_s)
+  end
+
+  def test_header
+    assert_equal(11, @patchdiag.header.length)
   end
 
   def test_last
-    assert_equal( '115302-01', @patchdiag.last.patch.to_s )
+    assert_equal('115302-01', @patchdiag.last.patch.to_s)
   end
 
   def test_latest
-    assert_raise( Solaris::Patch::NotFound ) do
-      @patchdiag.latest( 123456 )
+    assert_raise(Solaris::Patch::NotFound) do
+      @patchdiag.latest(123456)
     end
-    assert_equal( '100791-05', @patchdiag.latest( 100791 ).patch.to_s )
-    assert_equal( '100791-05', @patchdiag.latest( '100791' ).patch.to_s )
-    assert_equal( '100791-05', @patchdiag.latest( '100791-01' ).patch.to_s )
-    assert_equal( '100791-05', @patchdiag.latest( '100791-05' ).patch.to_s )
-    assert_equal( '100791-05', @patchdiag.latest( Solaris::Patch.new( 100791 ) ).patch.to_s )
-    assert_equal( '100791-05', @patchdiag.latest( Solaris::Patch.new( '100791' ) ).patch.to_s )
-    assert_equal( '100791-05', @patchdiag.latest( Solaris::Patch.new( '100791-01' ) ).patch.to_s )
-    assert_equal( '100791-05', @patchdiag.latest( Solaris::Patch.new( '100791-05' ) ).patch.to_s )
+    assert_equal('100791-05', @patchdiag.latest(100791).patch.to_s)
+    assert_equal('100791-05', @patchdiag.latest('100791').patch.to_s)
+    assert_equal('100791-05', @patchdiag.latest('100791-01').patch.to_s)
+    assert_equal('100791-05', @patchdiag.latest('100791-05').patch.to_s)
+    assert_equal('100791-05', @patchdiag.latest(Solaris::Patch.new(100791)).patch.to_s)
+    assert_equal('100791-05', @patchdiag.latest(Solaris::Patch.new('100791')).patch.to_s)
+    assert_equal('100791-05', @patchdiag.latest(Solaris::Patch.new('100791-01')).patch.to_s)
+    assert_equal('100791-05', @patchdiag.latest(Solaris::Patch.new('100791-05')).patch.to_s)
   end
 
   def test_sort
-    assert_equal( '115302-01', @patchdiag.entries.last.patch.to_s )
+    assert_equal('115302-01', @patchdiag.entries.last.patch.to_s)
     sorted = @patchdiag.sort
-    assert_equal( Solaris::Patchdiag, sorted.class )
-    assert_equal( '800054-01', sorted.entries.last.patch.to_s )
-    assert_equal( '115302-01', @patchdiag.entries.last.patch.to_s )
+    assert_equal(Solaris::Patchdiag, sorted.class)
+    assert_equal('800054-01', sorted.entries.last.patch.to_s)
+    assert_equal('115302-01', @patchdiag.entries.last.patch.to_s)
   end
 
   def test_sort!
-    assert_equal( '115302-01', @patchdiag.entries.last.patch.to_s )
+    assert_equal('115302-01', @patchdiag.entries.last.patch.to_s)
     size = @patchdiag.entries.size
     ret = @patchdiag.sort!
-    assert_equal( @patchdiag, ret )
-    assert_equal( size, @patchdiag.entries.size )
-    assert_equal( Solaris::Patchdiag, @patchdiag.class )
-    assert_equal( '800054-01', @patchdiag.entries.last.patch.to_s )
+    assert_equal(@patchdiag, ret)
+    assert_equal(size, @patchdiag.entries.size)
+    assert_equal(Solaris::Patchdiag, @patchdiag.class)
+    assert_equal('800054-01', @patchdiag.entries.last.patch.to_s)
   end
 
   def test_successor
-    assert_raise( Solaris::Patch::NotFound ) do
-      @patchdiag.latest( 123456 )
+    assert_raise(Solaris::Patch::NotFound) do
+      @patchdiag.latest(123456)
     end
-    assert_equal( '100287-05', @patchdiag.successor( 100287 ).patch.to_s )
-    assert_equal( '100287-05', @patchdiag.successor( '100287' ).patch.to_s )
-    assert_equal( '100287-05', @patchdiag.successor( '100287-05' ).patch.to_s )
-    assert_equal( '100287-05', @patchdiag.successor( Solaris::Patch.new( '100287-05' ) ).patch.to_s )
-    assert_equal( '100974-02', @patchdiag.successor( 100791 ).patch.to_s )
-    assert_raise( Solaris::Patch::NotFound ) do
-      @patchdiag.successor( 123456 )
+    assert_equal('100287-05', @patchdiag.successor(100287).patch.to_s)
+    assert_equal('100287-05', @patchdiag.successor('100287').patch.to_s)
+    assert_equal('100287-05', @patchdiag.successor('100287-05').patch.to_s)
+    assert_equal('100287-05', @patchdiag.successor(Solaris::Patch.new('100287-05')).patch.to_s)
+    assert_equal('100974-02', @patchdiag.successor(100791).patch.to_s)
+    assert_raise(Solaris::Patch::NotFound) do
+      @patchdiag.successor(123456)
     end
-    assert_raise( Solaris::Patch::NotFound ) do
-      @patchdiag.successor( 100393 ) # successor 100394 not in patchdiag.xref
+    assert_raise(Solaris::Patch::NotFound) do
+      @patchdiag.successor(100393) # successor 100394 not in patchdiag.xref
     end
-    assert_raise( Solaris::Patch::NotFound ) do
-      @patchdiag.successor( '654322-05' )
+    assert_raise(Solaris::Patch::NotFound) do
+      @patchdiag.successor('654322-05')
     end
-    assert_equal( '100807-04', @patchdiag.successor( '100807-01' ).patch.to_s )
-    assert_raise( Solaris::Patch::InvalidSuccessor ) do
-      @patchdiag.successor( '100807-03' ) # successor 100807-03 WITHDRAWN
+    assert_equal('100807-04', @patchdiag.successor('100807-01').patch.to_s)
+    assert_raise(Solaris::Patch::InvalidSuccessor) do
+      @patchdiag.successor('100807-03') # successor 100807-03 WITHDRAWN
     end
-    assert_raise( Solaris::Patch::SuccessorLoop ) do
-      @patchdiag.successor( 654321 )
+    assert_raise(Solaris::Patch::SuccessorLoop) do
+      @patchdiag.successor(654321)
     end
-    assert_raise( Solaris::Patch::SuccessorLoop ) do
-      @patchdiag.successor( '654321-01' )
+    assert_raise(Solaris::Patch::SuccessorLoop) do
+      @patchdiag.successor('654321-01')
     end
-    assert_raise( Solaris::Patch::NotFound ) do
-      @patchdiag.successor( 115302 )
+    assert_raise(Solaris::Patch::NotFound) do
+      @patchdiag.successor(115302)
     end
   end
 
   def test_successors
-    assert_equal( %w{ 100791 100791-05 100974 100974-02 },
-                 @patchdiag.successors( 100791 ).map(&:to_s) )
+    assert_equal(%w{ 100791 100791-05 100974 100974-02 },
+                 @patchdiag.successors(100791).map(&:to_s))
   end
 
   def test_download!
     skip 'Mock required'
   end
 
+  def test_to_s
+    assert_equal(@patchdiag_string, @patchdiag.to_s)
+  end
+
   private
 
   def successor(patch)
-    @patchdiag.successor( patch ).patch.to_s
+    @patchdiag.successor(patch).patch.to_s
   end
 
 end
-