xmlss 0.2.0 → 0.2.1

data/test/style/protection_test.rb

@@ -1,45 +1,41 @@
-require "test/helper"
+require "assert"
 require 'xmlss/style/protection'
 
-class Xmlss::Style::ProtectionTest < Test::Unit::TestCase
+module Xmlss::Style
 
-  context "Xmlss::Style::Protection" do
-    subject { Xmlss::Style::Protection.new }
+  class ProtectionTest < Assert::Context
+    desc "Xmlss::Style::Protection"
+    before { @sp = Xmlss::Style::Protection.new }
+    subject { @sp }
 
-    should_have_instance_methods :protected?
-    should_have_accessor :protect
+    should have_instance_methods :protected?
+    should have_accessor :protect
 
     should "set it's defaults" do
       assert_equal false, subject.protected?
     end
 
-    context "that sets attributes at init" do
-      subject do
-        Xmlss::Style::Protection.new({
-          :protect => true
-        })
-      end
+    should "set attrs at init time" do
+      sp = Xmlss::Style::Protection.new({
+        :protect => true
+      })
+      assert sp.protected?
+    end
 
-      should "should set them correctly" do
-        assert subject.protected?
-      end
+    should "set attrs after init time" do
+      subject.protect = true
+      assert subject.protected?
     end
 
-    context "that sets attributes after init" do
-      before do
-        subject.protect = true
-      end
+  end
 
-      should "should set them correctly" do
-        assert subject.protected?
-      end
-    end
+  class ProtectionXmlTest < ProtectionTest
+    desc "for generating XML"
 
-    context "for generating XML" do
-      should_have_reader :xml
-      should_build_node
-      should_build_no_attributes_by_default(Xmlss::Style::Alignment)
-    end
+    should have_reader :xml
+    should_build_node
+    should_build_no_attributes_by_default(Xmlss::Style::Alignment)
 
   end
+
 end

data/test/table_test.rb

@@ -1,53 +1,56 @@
-require "test/helper"
+require "assert"
 require 'xmlss/table'
 
 module Xmlss
-  class TableTest < Test::Unit::TestCase
-
-    context "Xmlss::Table" do
-      subject { Table.new }
-
-      should_have_accessor :columns, :rows
-
-      should "set it's defaults" do
-        assert_equal [], subject.columns
-        assert_equal [], subject.rows
-      end
-
-      should "allow defining a rows/columns at init" do
-        tbl = Table.new({
-          :columns => [Column.new],
-          :rows => [Row.new]
-        })
-
-        assert_equal 1, tbl.columns.size
-        assert_kind_of Column, tbl.columns.first
-        assert_equal 1, tbl.rows.size
-        assert_kind_of Row, tbl.rows.first
-      end
-
-      context "for generating XML" do
-        should_have_reader :xml
-        should_build_node
-      end
-
-      context "when using rows/columns" do
-        before do
-          subject.columns << Column.new
-          r = Row.new
-          r.cells << Cell.new
-          subject.rows << r
-        end
-
-        should "should build a table object" do
-          assert_equal 1, subject.columns.size
-          assert_kind_of Column, subject.columns.first
-          assert_equal 1, subject.rows.size
-          assert_kind_of Row, subject.rows.first
-        end
-      end
+  class TableTest < Assert::Context
+    desc "Xmlss::Table"
+    before { @tbl = Table.new }
+    subject { @tbl }
 
+    should have_accessor :columns, :rows
+
+    should "set it's defaults" do
+      assert_equal [], subject.columns
+      assert_equal [], subject.rows
+    end
+
+    should "allow defining a rows/columns at init" do
+      tbl = Table.new({
+        :columns => [Column.new],
+        :rows => [Row.new]
+      })
+
+      assert_equal 1, tbl.columns.size
+      assert_kind_of Column, tbl.columns.first
+      assert_equal 1, tbl.rows.size
+      assert_kind_of Row, tbl.rows.first
+    end
+
+  end
+
+  class TableXmlTest < TableTest
+    desc "for generating XML"
+    should have_reader :xml
+    should_build_node
+
+  end
+
+  class TableRowsColsTest < TableTest
+    desc "when using rows/columns"
+    before do
+      subject.columns << Column.new
+      r = Row.new
+      r.cells << Cell.new
+      subject.rows << r
+    end
+
+    should "should build a table object" do
+      assert_equal 1, subject.columns.size
+      assert_kind_of Column, subject.columns.first
+      assert_equal 1, subject.rows.size
+      assert_kind_of Row, subject.rows.first
     end
 
   end
+
 end

data/test/workbook_test.rb

@@ -1,62 +1,67 @@
-require "test/helper"
+require "assert"
 require 'xmlss/workbook'
 
 module Xmlss
-  class WorkbookTest < Test::Unit::TestCase
+  class WorkbookTest < Assert::Context
+    desc "Xmlss::Workbook"
+    before { @wkbk = Workbook.new }
+    subject { @wkbk }
 
-    context "Xmlss::Workbook" do
-      subject { Workbook.new }
+    should have_accessor :styles, :worksheets
+    should have_instance_method :to_xml
 
-      should_have_accessor :styles, :worksheets
-      should_have_instance_method :to_xml
+    should "set it's defaults" do
+      assert_equal [], subject.styles
+      assert_equal [], subject.worksheets
+    end
 
-      should "set it's defaults" do
-        assert_equal [], subject.styles
-        assert_equal [], subject.worksheets
-      end
+  end
 
-      context "when initializing with attrs" do
-        subject do
-          # specifying attrs at init time
-          Workbook.new({
-            :worksheets => [Worksheet.new('sheet1')]
-          })
-        end
-        before do
-          # writing attrs at run time
-          subject.styles = [
-            Xmlss::Style::Base.new('title') do
-              alignment({:horizontal => :left})
-              font({:size => 14, :bold => true})
-            end,
-
-            Xmlss::Style::Base.new('header') do
-              alignment({:horizontal => :left})
-              font({:bold => true})
-              [:top, :right, :bottom, :left].each do |p|
-                border({:position => :p})
-              end
-            end
-          ]
-        end
+  class WorkbookAttrsTest < Assert::Context
+    desc "when initializing with attrs"
+    subject { @wkbk }
+    before do
+      # specifying attrs at init time
+      @wkbk = Workbook.new({
+        :worksheets => [Worksheet.new('sheet1')]
+      })
 
-        should "build the attrs appropriately" do
-          [:worksheets, :styles].each do |thing|
-            assert_kind_of ItemSet, subject.send(thing)
-          end
-          assert_kind_of Worksheet, subject.worksheets.first
-          assert_equal 1, subject.worksheets.size
+      # writing attrs at run time
+      @wkbk.styles = [
+        Xmlss::Style::Base.new('title') do
+          alignment({:horizontal => :left})
+          font({:size => 14, :bold => true})
+        end,
 
-          assert_kind_of Style::Base, subject.styles.first
-          assert_equal 2, subject.styles.size
+        Xmlss::Style::Base.new('header') do
+          alignment({:horizontal => :left})
+          font({:bold => true})
+          [:top, :right, :bottom, :left].each do |p|
+            border({:position => :p})
+          end
         end
-      end
+      ]
+    end
 
-      context "for generating XML" do
-        should_have_reader :xml
-        should_build_node
+    should "build the attrs appropriately" do
+      [:worksheets, :styles].each do |thing|
+        assert_kind_of ItemSet, subject.send(thing)
       end
+      assert_kind_of Worksheet, subject.worksheets.first
+      assert_equal 1, subject.worksheets.size
+
+      assert_kind_of Style::Base, subject.styles.first
+      assert_equal 2, subject.styles.size
     end
 
   end
+
+  class WorkbookXmlTest < WorkbookTest
+    desc "for generating XML"
+
+    should have_reader :xml
+    should_build_node
+
+  end
+
 end

data/test/worksheet_test.rb

@@ -1,68 +1,69 @@
-require "test/helper"
+require "assert"
 require 'xmlss/worksheet'
 
 module Xmlss
-  class WorksheetTest < Test::Unit::TestCase
+  class WorksheetTest < Assert::Context
+    desc "Xmlss::Worksheet"
+    before { @wksht = Worksheet.new('sheet') }
+    subject { @wksht }
 
-    context "Xmlss::Worksheet" do
-      subject { Worksheet.new('sheet') }
+    should have_accessor :name, :table
 
-      should_have_accessor :name, :table
-
-      should "set it's defaults" do
-        assert_equal 'sheet', subject.name
-        assert_kind_of Table, subject.table
-        assert_equal [], subject.table.columns
-        assert_equal [], subject.table.rows
-      end
+    should "set it's defaults" do
+      assert_equal 'sheet', subject.name
+      assert_kind_of Table, subject.table
+      assert_equal [], subject.table.columns
+      assert_equal [], subject.table.rows
+    end
 
-      should "filter name chars" do
-        # worksheet name cannot contain: /, \, :, ;, * or start with '['
-        assert_equal "test test", Worksheet.new("test/ test").name
-        assert_equal "test test", Worksheet.new("tes\\t test").name
-        assert_equal "test test", Worksheet.new("te:st test:").name
-        ws = Worksheet.new("te;st ;test")
-        assert_equal "test test", ws.name
-        ws.name = "t*est test"
-        assert_equal "test test", ws.name
-        ws.name = "[te]st test"
-        assert_equal "te]st test", ws.name
-        ws.name = "t[e]st test"
-        assert_equal "t[e]st test", ws.name
-      end
+    should "filter name chars" do
+      # worksheet name cannot contain: /, \, :, ;, * or start with '['
+      assert_equal "test test", Worksheet.new("test/ test").name
+      assert_equal "test test", Worksheet.new("tes\\t test").name
+      assert_equal "test test", Worksheet.new("te:st test:").name
+      ws = Worksheet.new("te;st ;test")
+      assert_equal "test test", ws.name
+      ws.name = "t*est test"
+      assert_equal "test test", ws.name
+      ws.name = "[te]st test"
+      assert_equal "te]st test", ws.name
+      ws.name = "t[e]st test"
+      assert_equal "t[e]st test", ws.name
+    end
 
-      should "allow defining a table at init" do
-        wksht = Worksheet.new('table', {
-          :table => Table.new({
-            :columns => [Column.new]
-          })
+    should "allow defining a table at init" do
+      wksht = Worksheet.new('table', {
+        :table => Table.new({
+          :columns => [Column.new]
         })
+      })
 
-        assert_equal 1, wksht.table.columns.size
-        assert_kind_of Column, wksht.table.columns.first
-      end
+      assert_equal 1, wksht.table.columns.size
+      assert_kind_of Column, wksht.table.columns.first
+    end
 
-      should "bark when no name is given" do
-        assert_raises ArgumentError do
-          Worksheet.new(nil)
-        end
-        assert_raises ArgumentError do
-          Worksheet.new("")
-        end
+    should "bark when no name is given" do
+      assert_raises ArgumentError do
+        Worksheet.new(nil)
       end
-
-      should "bark when setting a table to something other" do
-        assert_raises ArgumentError do
-          subject.table = "not a table"
-        end
+      assert_raises ArgumentError do
+        Worksheet.new("")
       end
+    end
 
-      context "for generating XML" do
-        should_have_reader :xml
-        should_build_node
+    should "bark when setting a table to something other" do
+      assert_raises ArgumentError do
+        subject.table = "not a table"
       end
-
     end
 
   end
+
+  class WorksheetXmlTest < WorksheetTest
+    desc "for generating XML"
+
+    should have_reader :xml
+    should_build_node
+  end
+
 end

data/test/xml_test.rb

@@ -1,80 +1,81 @@
-require "test/helper"
+require "assert"
 require 'test/thing'
 
 module Xmlss
-  class XmlTest < Test::Unit::TestCase
+  class XmlTest < Assert::Context
+    desc "Xmlss::Xml"
+    before { @thing = Thing.new }
+    subject { @thing }
 
-    context "Xmlss::Xml" do
-      subject { Thing.new }
-
-      should "should provide proper namespace constants" do
-        assert_equal "xmlns", Xmlss::XML_NS
-        assert_equal "ss", Xmlss::SHEET_NS
-        assert_equal "urn:schemas-microsoft-com:office:spreadsheet", Xmlss::NS_URI
-      end
+    should "should provide proper namespace constants" do
+      assert_equal "xmlns", Xmlss::XML_NS
+      assert_equal "ss", Xmlss::SHEET_NS
+      assert_equal "urn:schemas-microsoft-com:office:spreadsheet", Xmlss::NS_URI
+    end
 
-      should "bark if you use xml generation without configuring" do
-        assert_raises ArgumentError do
-          ::Nokogiri::XML::Builder.new do |builder|
-            subject.build_node(builder)
-          end
+    should "bark if you use xml generation without configuring" do
+      assert_raises ArgumentError do
+        ::Nokogiri::XML::Builder.new do |builder|
+          subject.build_node(builder)
         end
       end
+    end
 
-      context "with config" do
-        before do
-          subject.xml = {
-            :node => :thing,
-            :attributes => [:one, :two, :three],
-            :children => [:child_nodes]
-          }
-          subject.one = true
-          subject.two = "two"
-          subject.three = ""
-        end
+  end
 
-        should "build it's node" do
-          assert_nothing_raised do
-            ::Nokogiri::XML::Builder.new do |builder|
-              subject.build_node(builder)
-            end
-          end
-        end
+  class XmlConfigTest < XmlTest
+    desc "with config"
+    before do
+      subject.xml = {
+        :node => :thing,
+        :attributes => [:one, :two, :three],
+        :children => [:child_nodes]
+      }
+      subject.one = true
+      subject.two = "two"
+      subject.three = ""
+    end
 
-        should "build with no whitespace formatting by default" do
-          assert_equal(
-            "<?xml version=\"1.0\"?>\n<Thing ss:One=\"1\" ss:Two=\"two\"><Nodes/></Thing>\n",
-            ::Nokogiri::XML::Builder.new do |builder|
-              subject.build_node(builder)
-            end.to_xml({:save_with => subject.xml_save_with})
-          )
+    should "build it's node" do
+      assert_nothing_raised do
+        ::Nokogiri::XML::Builder.new do |builder|
+          subject.build_node(builder)
         end
+      end
+    end
 
-        should "build with whitespace formatting if specified" do
-          assert_equal(
-            "<?xml version=\"1.0\"?>\n<Thing ss:One=\"1\" ss:Two=\"two\">\n  <Nodes/>\n</Thing>\n",
-            ::Nokogiri::XML::Builder.new do |builder|
-              subject.build_node(builder)
-            end.to_xml({:save_with => subject.xml_save_with(:format)})
-          )
-        end
+    should "build with no whitespace formatting by default" do
+      assert_equal(
+        "<?xml version=\"1.0\"?>\n<Thing ss:One=\"1\" ss:Two=\"two\"><Nodes/></Thing>\n",
+        ::Nokogiri::XML::Builder.new do |builder|
+          subject.build_node(builder)
+        end.to_xml({:save_with => subject.xml_save_with})
+      )
+    end
 
-        should "generate build attributes based on it's own attributes" do
-          assert_nothing_raised do
-            subject.send :build_attributes
-          end
-          attrs = subject.send :build_attributes
+    should "build with whitespace formatting if specified" do
+      assert_equal(
+        "<?xml version=\"1.0\"?>\n<Thing ss:One=\"1\" ss:Two=\"two\">\n  <Nodes/>\n</Thing>\n",
+        ::Nokogiri::XML::Builder.new do |builder|
+          subject.build_node(builder)
+        end.to_xml({:save_with => subject.xml_save_with(:format)})
+      )
+    end
 
-          assert_kind_of ::Hash, attrs
-          assert attrs.has_key?("#{Xmlss::SHEET_NS}:One")
-          assert_equal 1, attrs["#{Xmlss::SHEET_NS}:One"]
-          assert attrs.has_key?("#{Xmlss::SHEET_NS}:Two")
-          assert_equal 'two', attrs["#{Xmlss::SHEET_NS}:Two"]
-          assert !attrs.has_key?("#{Xmlss::SHEET_NS}:Three")
-        end
+    should "generate build attributes based on it's own attributes" do
+      assert_nothing_raised do
+        subject.send :build_attributes
       end
+      attrs = subject.send :build_attributes
 
+      assert_kind_of ::Hash, attrs
+      assert attrs.has_key?("#{Xmlss::SHEET_NS}:One")
+      assert_equal 1, attrs["#{Xmlss::SHEET_NS}:One"]
+      assert attrs.has_key?("#{Xmlss::SHEET_NS}:Two")
+      assert_equal 'two', attrs["#{Xmlss::SHEET_NS}:Two"]
+      assert !attrs.has_key?("#{Xmlss::SHEET_NS}:Three")
     end
 
   end
+
 end