xmlss 0.2.0 → 0.2.1

data/test/style/border_test.rb

@@ -1,12 +1,14 @@
-require "test/helper"
+require "assert"
 require 'xmlss/style/border'
 
-class Xmlss::Style::BorderTest < Test::Unit::TestCase
+module Xmlss::Style
+  class BorderTest < Assert::Context
+    desc "Xmlss::Style::Border"
+    before { @b = Xmlss::Style::Border.new }
+    subject { @b }
 
-  context "Xmlss::Style::Border" do
-    subject { Xmlss::Style::Border.new }
+    should have_class_method :position
 
-    should_have_class_method :position
     {
       :left => "Left",
       :top => "Top",
@@ -16,11 +18,12 @@ class Xmlss::Style::BorderTest < Test::Unit::TestCase
       :diagonal_right => "DiagonalRight"
     }.each do |position, value|
       should "provide the value for the '#{position}' position" do
-        assert_equal value, Xmlss::Style::Border.position(position)
+        assert_equal value, Border.position(position)
       end
     end
 
-    should_have_class_method :weight
+    should have_class_method :weight
+
     {
       :hairline => 0,
       :thin => 1,
@@ -28,11 +31,12 @@ class Xmlss::Style::BorderTest < Test::Unit::TestCase
       :thick => 3
     }.each do |weight, value|
       should "provide the value for the '#{weight}' weight" do
-        assert_equal value, Xmlss::Style::Border.weight(weight)
+        assert_equal value, Border.weight(weight)
       end
     end
 
-    should_have_class_method :line_style
+    should have_class_method :line_style
+
     {
       :none => "None",
       :continuous => "Continuous",
@@ -42,73 +46,63 @@ class Xmlss::Style::BorderTest < Test::Unit::TestCase
       :dash_dot_dot => "DashDotDot"
     }.each do |style, value|
       should "provide the value for the '#{style}' line_style" do
-        assert_equal value, Xmlss::Style::Border.line_style(style)
+        assert_equal value, Border.line_style(style)
       end
     end
 
-    should_have_accessors :color, :position, :weight, :line_style
+    should have_accessors :color, :position, :weight, :line_style
 
     should "set it's defaults" do
       assert_equal nil, subject.color
       assert_equal nil, subject.position
-      assert_equal Xmlss::Style::Border.weight(:thin), subject.weight
-      assert_equal Xmlss::Style::Border.line_style(:continuous), subject.line_style
+      assert_equal Border.weight(:thin), subject.weight
+      assert_equal Border.line_style(:continuous), subject.line_style
     end
 
-    context "that sets attributes at init" do
-      before do
-        @attrs = {
-          :color => '#FF0000',
-          :position => :top,
-          :weight => :thick,
-          :line_style => :dot
-        }
-        @border = Xmlss::Style::Border.new(@attrs)
-      end
-      subject{ @border }
-
-      should "should set them correctly" do
-        @attrs.reject{|a, v| [:position, :weight, :line_style].include?(a)}.each do |a,v|
-          assert_equal v, subject.send(a)
-        end
-        assert_equal Xmlss::Style::Border.position(:top), subject.position
-        assert_equal Xmlss::Style::Border.weight(:thick), subject.weight
-        assert_equal Xmlss::Style::Border.line_style(:dot), subject.line_style
+    should "set attrs at init" do
+      attrs = {
+        :color => '#FF0000',
+        :position => :top,
+        :weight => :thick,
+        :line_style => :dot
+      }
+      border = Border.new(attrs)
+
+      attrs.reject{|a, v| [:position, :weight, :line_style].include?(a)}.each do |a,v|
+        assert_equal v, border.send(a)
       end
+      assert_equal Border.position(:top), border.position
+      assert_equal Border.weight(:thick), border.weight
+      assert_equal Border.line_style(:dot), border.line_style
     end
 
-    context "that sets position, weight, and style by key" do
-      before do
-        subject.position = :bottom
-        subject.weight = :medium
-        subject.line_style = :dash_dot
-      end
+    should "set attrs by key" do
+      subject.position = :bottom
+      subject.weight = :medium
+      subject.line_style = :dash_dot
 
-      should "should returm it by value" do
-        assert_equal Xmlss::Style::Border.position(:bottom), subject.position
-        assert_equal Xmlss::Style::Border.weight(:medium), subject.weight
-        assert_equal Xmlss::Style::Border.line_style(:dash_dot), subject.line_style
-      end
+      assert_equal Border.position(:bottom), subject.position
+      assert_equal Border.weight(:medium), subject.weight
+      assert_equal Border.line_style(:dash_dot), subject.line_style
     end
 
-    context "that sets position, weight, and style by value" do
-      before do
-        subject.position = Xmlss::Style::Border.position(:bottom)
-        subject.weight = Xmlss::Style::Border.weight(:medium)
-        subject.line_style = Xmlss::Style::Border.line_style(:dash_dot)
-      end
+    should "set attrs by value" do
+      subject.position = Border.position(:bottom)
+      subject.weight = Border.weight(:medium)
+      subject.line_style = Border.line_style(:dash_dot)
 
-      should "should returm it by value" do
-        assert_equal Xmlss::Style::Border.position(:bottom), subject.position
-        assert_equal Xmlss::Style::Border.weight(:medium), subject.weight
-        assert_equal Xmlss::Style::Border.line_style(:dash_dot), subject.line_style
-      end
+      assert_equal Border.position(:bottom), subject.position
+      assert_equal Border.weight(:medium), subject.weight
+      assert_equal Border.line_style(:dash_dot), subject.line_style
     end
 
-    context "for generating XML" do
-      should_have_reader :xml
-      should_build_node
-    end
+  end
+
+  class BorderXmlTest < BorderTest
+    desc "for generating XML"
+    should have_reader :xml
+    should_build_node
 
   end
+
 end

data/test/style/font_test.rb

@@ -1,12 +1,14 @@
-require "test/helper"
+require "assert"
 require 'xmlss/style/font'
 
-class Xmlss::Style::FontTest < Test::Unit::TestCase
+module Xmlss::Style
+  class FontTest < Assert::Context
+    desc "Xmlss::Style::Font"
+    before { @f = Font.new }
+    subject { @f }
 
-  context "Xmlss::Style::Font" do
-    subject { Xmlss::Style::Font.new }
+    should have_class_method :underline
 
-    should_have_class_method :underline
     {
       :single => 'Single',
       :double => 'Double',
@@ -18,7 +20,8 @@ class Xmlss::Style::FontTest < Test::Unit::TestCase
       end
     end
 
-    should_have_class_method :alignment
+    should have_class_method :alignment
+
     {
       :subscript => 'Subscript',
       :superscript => 'Superscript'
@@ -28,10 +31,10 @@ class Xmlss::Style::FontTest < Test::Unit::TestCase
       end
     end
 
-    should_have_accessors :bold, :color, :italic, :size, :strike_through, :shadow
-    should_have_accessors :underline, :alignment
-    should_have_instance_methods :bold?, :italic?, :strike_through?, :shadow?
-    should_have_reader :vertical_align
+    should have_accessors :bold, :color, :italic, :size, :strike_through, :shadow
+    should have_accessors :underline, :alignment
+    should have_instance_methods :bold?, :italic?, :strike_through?, :shadow?
+    should have_reader :vertical_align
 
     should "set it's defaults" do
       assert_equal false, subject.bold
@@ -44,59 +47,49 @@ class Xmlss::Style::FontTest < Test::Unit::TestCase
       assert_equal nil, subject.alignment
     end
 
-    context "that sets attributes at init" do
-      before do
-        @attrs = {
-          :bold => true,
-          :color => '#FF0000',
-          :italic => true,
-          :size => 10,
-          :strike_through => true,
-          :underline => :single,
-          :alignment => :superscript
-        }
-        @font = Xmlss::Style::Font.new(@attrs)
-      end
-      subject{ @font }
-
-      should "should set them correctly" do
-        @attrs.reject{|a, v| [:underline, :alignment].include?(a)}.each do |a,v|
-          assert_equal v, subject.send(a)
-        end
-        assert_equal Xmlss::Style::Font.underline(:single), subject.underline
-        assert_equal Xmlss::Style::Font.alignment(:superscript), subject.alignment
+    should "set attrs at init" do
+      attrs = {
+        :bold => true,
+        :color => '#FF0000',
+        :italic => true,
+        :size => 10,
+        :strike_through => true,
+        :underline => :single,
+        :alignment => :superscript
+      }
+      font = Font.new(attrs)
+
+      attrs.reject{|a, v| [:underline, :alignment].include?(a)}.each do |a,v|
+        assert_equal v, font.send(a)
       end
+      assert_equal Font.underline(:single), font.underline
+      assert_equal Font.alignment(:superscript), font.alignment
     end
 
-    context "that sets underline and alignment by key" do
-      before do
-        subject.underline = :double
-        subject.alignment = :subscript
-      end
+    should "set attrs by key" do
+      subject.underline = :double
+      subject.alignment = :subscript
 
-      should "should returm it by value" do
-        assert_equal Xmlss::Style::Font.underline(:double), subject.underline
-        assert_equal Xmlss::Style::Font.alignment(:subscript), subject.alignment
-      end
+      assert_equal Font.underline(:double), subject.underline
+      assert_equal Font.alignment(:subscript), subject.alignment
     end
 
-    context "that sets underline and alignment by value" do
-      before do
-        subject.underline = Xmlss::Style::Font.underline(:double)
-        subject.alignment = Xmlss::Style::Font.alignment(:subscript)
-      end
+    should "set attrs by value" do
+      subject.underline = Xmlss::Style::Font.underline(:double)
+      subject.alignment = Xmlss::Style::Font.alignment(:subscript)
 
-      should "should returm it by value" do
-        assert_equal Xmlss::Style::Font.underline(:double), subject.underline
-        assert_equal Xmlss::Style::Font.alignment(:subscript), subject.alignment
-      end
+      assert_equal Xmlss::Style::Font.underline(:double), subject.underline
+      assert_equal Xmlss::Style::Font.alignment(:subscript), subject.alignment
     end
 
-    context "for generating XML" do
-      should_have_reader :xml
-      should_build_node
-      should_build_no_attributes_by_default(Xmlss::Style::Font)
-    end
+  end
 
+  class FontXmlTest < FontTest
+    desc "for generating XML"
+
+    should have_reader :xml
+    should_build_node
+    should_build_no_attributes_by_default(Xmlss::Style::Font)
   end
+
 end

data/test/style/interior_test.rb

@@ -1,12 +1,15 @@
-require "test/helper"
+require "assert"
 require 'xmlss/style/interior'
 
-class Xmlss::Style::InteriorTest < Test::Unit::TestCase
+module Xmlss::Style
 
-  context "Xmlss::Style::Interior" do
-    subject { Xmlss::Style::Interior.new }
+  class InteriorTest < Assert::Context
+    desc "Xmlss::Style::Interior"
+    before { @i = Interior.new }
+    subject { @i }
+
+    should have_class_method :pattern
 
-    should_have_class_method :pattern
     {
       :none => "None",
       :solid => "Solid",
@@ -33,7 +36,7 @@ class Xmlss::Style::InteriorTest < Test::Unit::TestCase
       end
     end
 
-    should_have_accessor :color, :pattern, :pattern_color
+    should have_accessor :color, :pattern, :pattern_color
 
     should "set it's defaults" do
       assert_equal nil, subject.color
@@ -41,47 +44,35 @@ class Xmlss::Style::InteriorTest < Test::Unit::TestCase
       assert_equal nil, subject.pattern_color
     end
 
-    context "that sets attributes at init" do
-      subject do
-        Xmlss::Style::Interior.new({
-          :color => "#000000",
-          :pattern => :solid,
-          :pattern_color => "#FF0000"
-        })
-      end
-
-      should "should set them correctly" do
-        assert_equal "#000000", subject.color
-        assert_equal "Solid", subject.pattern
-        assert_equal "#FF0000", subject.pattern_color
-      end
+    should "set attributes at init" do
+      i = Interior.new({
+        :color => "#000000",
+        :pattern => :solid,
+        :pattern_color => "#FF0000"
+      })
+      assert_equal "#000000", i.color
+      assert_equal "Solid", i.pattern
+      assert_equal "#FF0000", i.pattern_color
     end
 
-    context "that sets pattern by key" do
-      before do
-        subject.pattern = :solid
-      end
-
-      should "should returm them by value" do
-        assert_equal "Solid", subject.pattern
-      end
+    should "set attrs by key" do
+      subject.pattern = :solid
+      assert_equal "Solid", subject.pattern
     end
 
-    context "that sets attributes by value" do
-      before do
-        subject.pattern = "Solid"
-      end
-
-      should "should returm them by value" do
-        assert_equal "Solid", subject.pattern
-      end
+    should "set attrs by value" do
+      subject.pattern = "Solid"
+      assert_equal "Solid", subject.pattern
     end
 
-    context "for generating XML" do
-      should_have_reader :xml
-      should_build_node
-      should_build_no_attributes_by_default(Xmlss::Style::Alignment)
-    end
+  end
+
+  class InteriorXmlTest < InteriorTest
+    desc "for generating XML"
 
+    should have_reader :xml
+    should_build_node
+    should_build_no_attributes_by_default(Xmlss::Style::Alignment)
   end
+
 end

data/test/style/number_format_test.rb

@@ -1,50 +1,39 @@
-require "test/helper"
+require "assert"
 require 'xmlss/style/number_format'
 
-class Xmlss::Style::NumberFormatTest < Test::Unit::TestCase
+module Xmlss::Style
+  class NumberFormatTest < Assert::Context
+    desc "Xmlss::Style::NumberFormat"
+    before { @nf = NumberFormat.new }
+    subject { @nf }
 
-  context "Xmlss::Style::NumberFormat" do
-    subject { Xmlss::Style::NumberFormat.new }
+    should have_accessor :format
 
-    should_have_accessor :format
-
-    context "that sets attributes at init" do
-      subject do
-        Xmlss::Style::NumberFormat.new({
-          :format => "General"
-        })
-      end
-
-      should "should set them correctly" do
-        assert_equal "General", subject.format
-      end
+    should "set attributes at init" do
+      nf = Xmlss::Style::NumberFormat.new({
+        :format => "General"
+      })
+      assert_equal "General", nf.format
     end
 
-    context "that sets format by key" do
-      before do
-        subject.format = "@"
-      end
-
-      should "should returm it by value" do
-        assert_equal "@", subject.format
-      end
+    should "set format by key" do
+      subject.format = "@"
+      assert_equal "@", subject.format
     end
 
-    context "that sets format by value" do
-      before do
-        subject.format = "True/False"
-      end
-
-      should "should returm it by value" do
-        assert_equal "True/False", subject.format
-      end
+    should "set format by value" do
+      subject.format = "True/False"
+      assert_equal "True/False", subject.format
     end
 
-    context "for generating XML" do
-      should_have_reader :xml
-      should_build_node
-      should_build_no_attributes_by_default(Xmlss::Style::Alignment)
-    end
+  end
 
+  class NumberFormatXmlTest < NumberFormatTest
+    desc "for generating XML"
+
+    should have_reader :xml
+    should_build_node
+    should_build_no_attributes_by_default(Xmlss::Style::Alignment)
   end
+
 end