using shoulda context for clearer tests

Author: camilo

.document

@@ -1,5 +1,6 @@
 lib/**/*.rb
 bin/*
+ext/*.c
 - 
 features/**/*.feature
 LICENSE.txt

test/test_document.rb

@@ -3,53 +3,59 @@
 
 class TestDocument < Test::Unit::TestCase
 
-  def test_create
-    d = Document.create(0, 0.5, 1, 0, [[1, 1.0 ], [4, 0.0] , [10, 0.0] ,[ 11, 0.5 ]])
-    assert_kind_of Document, d
-  end
-
-  def test_create_should_accept_integer_as_feature_weight
-    d = Document.create(0, 0.5, 1, 0, [[1, 0 ], [4, 0.0] , [10, 0.0] ,[ 11, 0.5 ]])
-    assert_kind_of Document, d
-  end
+  context "creating a new document" do
+    
+    should "succed when using #create" do
+      d = Document.create(0, 0.5, 1, 0, [[1, 1.0 ], [4, 0.0] , [10, 0.0] ,[ 11, 0.5 ]])
+      assert_kind_of Document, d
+    end
+
+    should "accept integers as feature weights" do 
+      d = Document.create(0, 0.5, 1, 0, [[1, 0 ], [4, 0.0] , [10, 0.0] ,[ 11, 0.5 ]])
+      assert_kind_of Document, d
+    end
+
+    should "create documents useing new as well" do
+      d = Document.new({1 => 566.0, 4 => 133.0}, {docnum: 10, slackid: 1, queryid: 2, costfactor: 0.5}) 
+
+      assert_equal 10, d.docnum
+      assert_equal 1, d.slackid
+      assert_equal 2, d.queryid
+      assert_equal 0.5, d.costfactor
+    end
+
+    should "raise argument error if any of the word numbers is less or equal to 0" do 
+      assert_raise(ArgumentError){ Document.create(0, 0.5, 1, 0, [[0, 1.0 ], [10, 0.0 ], [20, 0.0], [21, 0.1 ]]) }
+      assert_raise(ArgumentError){ Document.create(1, 0.5, 1, 0, [[-1, 1.0 ], [30, 0.0 ], [40, 0.0], [41, 0.1 ]])}
+    end
+
+    should "raise type error when the fourth argument is not an array" do
+      assert_raise(TypeError) { Document.create(-1, 0, 1, 0, {})  }
+    end
+
+    should "raise type error when the fourth argument is empty" do
+      assert_raise(ArgumentError) { Document.create(-1, 0, 1, 0 [])}
+    end
 
-  def test_create_using_new
-    d = Document.new({1 => 566.0, 4 => 133.0}, {docnum: 10, slackid: 1, queryid: 2, costfactor: 0.5}) 
-
-    assert_equal 10, d.docnum
-    assert_equal 1, d.slackid
-    assert_equal 2, d.queryid
-    assert_equal 0.5, d.costfactor
   end
+  
+  context 'a document' do
+    should "have accessible docnum, queryid, slackid, and, costfacor" do
+      d1 = Document.create(0, 0.5, 1, 0, [[1, 1.0 ], [10, 0.0 ], [20, 0.0], [21, 0.1 ]])
+      d2 = Document.create(1, 0.6, 2, 1, [[1, 1.0 ], [30, 0.0 ], [40, 0.0], [41, 0.1 ]])
 
-  def test_should_be_able_to_access_properties
-    d1 = Document.create(0, 0.5, 1, 0, [[1, 1.0 ], [10, 0.0 ], [20, 0.0], [21, 0.1 ]])
-    d2 = Document.create(1, 0.6, 2, 1, [[1, 1.0 ], [30, 0.0 ], [40, 0.0], [41, 0.1 ]])
-
-    assert_equal 0, d1.docnum
-    assert_equal 1, d2.docnum
-
-    assert_equal 1, d1.slackid
-    assert_equal 2, d2.slackid
+      assert_equal 0, d1.docnum
+      assert_equal 1, d2.docnum
 
-    assert_equal 0, d1.queryid
-    assert_equal 1, d2.queryid
+      assert_equal 1, d1.slackid
+      assert_equal 2, d2.slackid
 
-    assert_equal 0.5, d1.costfactor
-    assert_equal 0.6, d2.costfactor
-  end
-
-  def test_all_word_numbers_should_be_greater_than_zero
-    assert_raise(ArgumentError){ Document.create(0, 0.5, 1, 0, [[0, 1.0 ], [10, 0.0 ], [20, 0.0], [21, 0.1 ]]) }
-    assert_raise(ArgumentError){ Document.create(1, 0.5, 1, 0, [[-1, 1.0 ], [30, 0.0 ], [40, 0.0], [41, 0.1 ]])}
-  end
-
-  def test_create_with_no_array
-    assert_raise(TypeError) { Document.create(-1, 0, 1, 0, {})  }
-  end
+      assert_equal 0, d1.queryid
+      assert_equal 1, d2.queryid
 
-  def test_create_with_empty_array
-    assert_raise(ArgumentError) { Document.create(-1, 0, 1, 0 [])}
+      assert_equal 0.5, d1.costfactor
+      assert_equal 0.6, d2.costfactor
+    end
   end
 end
 

test/test_model.rb

@@ -3,112 +3,117 @@
 
 class TestModel < Test::Unit::TestCase
 
-  def setup
-    @features ||= [
-      [ [1,0.6], [11, 0.0], [34, 0.1] ],
-      [ [5,0.4], [15, 0.0], [30, 0.1] ],
-      [ [1,0.1], [13, 0.0], [31, 0.1] ],
-      [ [7,0.7], [15, 0.0], [35, 0.1] ],
-      [ [5,0.6], [19, 0.0], [44, 0.1] ],
-    ]
-    @docs_and_labels ||= @features.each_with_index.map{|f,i| [ Document.create(i + 1, 1, 0, 0,  f), i%2 * -1]}
-  end
+  context "reading a model from file" do
+
+    setup do 
+      @file_name = 'test/assets/model'
+    end
 
-  def test_learn_classification_with_alpha
-    m = Model.new(:classification, @docs_and_labels, {}, {}, [1, 0.0] * 50)
-    assert_kind_of Model, m
+    should "read properly from a well formed file" do
+      assert m     = Model.read_from_file(@file_name)
+      assert_equal 3877,  m.support_vectors_count
+      assert_equal 39118, m.total_words
+    end
 
-    @docs_and_labels.each_with_index do |item, i|
-      assert_kind_of  Numeric, m.classify(item.first), "failed in item # #{i}"
+    should "classify successfully after reading the model from a file" do
+      m = Model.read_from_file(@file_name)
+      assert_kind_of Numeric, m.classify( Document.create(-1, 1, 0, 0,[1.0, 0, 0, 0, 0.5 ].each_with_index.map{|v, i| [i + 1 ,v.to_f]} ) )
+      assert_kind_of Numeric, m.classify( Document.create(-1, 1, 0, 0,[1.0, 0, 0, 0, 0.5 ].each_with_index.map{|v, i| [i + 1,v.to_f]}) )
+      assert_kind_of Numeric, m.classify( Document.create(-1, 1, 0, 0,[1, 0, 0, 0, 0.8, 0, 0 , 0 ].each_with_index.map{|v, i| [i + 1,v.to_f]}) )
+      assert_kind_of Numeric, m.classify( Document.create(-1, 1, 0, 0,[1, 0.5, 0, 0, 0, 0 , 0 ].each_with_index.map{|v, i| [i + 1,v.to_f]}) )
     end
   end
 
-  def test_learn_classification
-    m = Model.new(:classification, @docs_and_labels, {}, {}, nil)
-    assert_kind_of Model, m
-    assert_equal 44, m.total_words
-    assert_equal 5, m.totdoc
+  context "when learning from new documents" do
 
-    @docs_and_labels.each_with_index do |item, i|
-      assert_kind_of  Numeric, m.classify(item.first), "failed in item # #{i}"
+    setup do
+      @features ||= [
+        [ [1,0.6], [11, 0.0], [34, 0.1] ],
+        [ [5,0.4], [15, 0.0], [30, 0.1] ],
+        [ [1,0.1], [13, 0.0], [31, 0.1] ],
+        [ [7,0.7], [15, 0.0], [35, 0.1] ],
+        [ [5,0.6], [19, 0.0], [44, 0.1] ],
+      ]
+
+      @docs_and_labels ||= @features.each_with_index.map do |feature, index| 
+        [ Document.create(index + 1, 1, 0, 0,  feature), index%2 * -1]
+      end
     end
 
-  end
+    should "learn classification with default arguments" do
+      m = Model.new(:classification, @docs_and_labels, {}, {}, nil)
+      assert_kind_of Model, m
+      assert_equal 44, m.total_words
+      assert_equal 5, m.totdoc
+
+      @docs_and_labels.each_with_index do |item, i|
+        assert_kind_of  Numeric, m.classify(item.first), "failed in item # #{i}"
+      end
+    end
+
+    should "learn classification with alpha values" do
+      m = Model.new(:classification, @docs_and_labels, {}, {}, [1, 0.0] * 50)
+      assert_kind_of Model, m
+
+      @docs_and_labels.each_with_index do |item, i|
+        assert_kind_of  Numeric, m.classify(item.first), "failed in item # #{i}"
+      end
+    end
+
+    should "raise argument error when one of the alphas is not numeric " do 
+      assert_raises(ArgumentError){Model.new(:classification, @docs_and_labels, {}, {}, [1, {}] )}
+    end
 
-  def test_learn_classification_with_learn_params
-    
-    learn_params = {
+    should "learn classification and accept learn parameters" do
+      learn_params = {
        "predfile"            => "custom_file",
        "alphafile"           => "alpha",
        "biased_hyperplane"   => false,
        "sharedslack"         => false,
        "remove_inconsistent" => true
-    }
+      }
 
-    m = Model.new(:classification, @docs_and_labels, learn_params, {}, nil)
-    assert_kind_of Model, m
+      m = Model.new(:classification, @docs_and_labels, learn_params, {}, nil)
+      assert_kind_of Model, m
 
-    @docs_and_labels.each_with_index do |item, i|
-      assert_kind_of  Numeric, m.classify(item.first), "failed in item # #{i}"
+      @docs_and_labels.each_with_index do |item, i|
+        assert_kind_of  Numeric, m.classify(item.first), "failed in item # #{i}"
+      end
     end
-  end
 
-  def test_learn_classification_with_invalid_learn_params
-    learn_params = {"svm_c" =>  -1}
-    assert_raises(ArgumentError){Model.new(:classification, @docs_and_labels, learn_params, {}, nil)}
-    learn_params = {"svm_iter_to_shrink" =>  -1}
-    assert_raises(ArgumentError){Model.new(:classification, @docs_and_labels, learn_params, {}, nil)}
-  end
+    should "raise argument error when learn parameters are invalid" do
+      learn_params = {"svm_c" =>  -1}
+      assert_raises(ArgumentError){Model.new(:classification, @docs_and_labels, learn_params, {}, nil)}
+      learn_params = {"svm_iter_to_shrink" =>  -1}
+      assert_raises(ArgumentError){Model.new(:classification, @docs_and_labels, learn_params, {}, nil)}
+    end
+
+    should "learn calssification while accepting kernel paramters" do
 
-  def test_learn_classification_with_kernel_params
-    
-    kernel_params = {
+      kernel_params = {
       "poly_degree" => 3,
       "rbf_gamma"   => 0.5,
       "coef_lin"    => 0.4,
       "coef_const"  => 0.56
-    }
+      }
 
-    m = Model.new(:classification, @docs_and_labels, {}, kernel_params, nil)
-    assert_kind_of Model, m
+      m = Model.new(:classification, @docs_and_labels, {}, kernel_params, nil)
+      assert_kind_of Model, m
 
-    @docs_and_labels.each_with_index do |item, i|
-      assert_kind_of  Numeric, m.classify(item.first), "failed in item # #{i}"
-    end
-  end
-  
-  def test_learn_classification_with_learn_params_when_predfile_is_not_string
-    
-    learn_params = { "predfile"  => {}}
-  
-    assert_raise(ArgumentError) do
-      Model.new(:classification, @docs_and_labels, learn_params, {}, [1, 0.0, 1])
+      @docs_and_labels.each_with_index do |item, i|
+        assert_kind_of  Numeric, m.classify(item.first), "failed in item # #{i}"
+      end
     end
 
-  end
+    should "raise argument error when predfile is not string" do
 
-  def test_learn_classification_fails_when_element_is_not_array
-    @docs_and_labels << []
-    assert_raises(ArgumentError){Model.new(:classification, @docs_and_labels, {}, {}, nil)}
-  end
-
-  def test_learn_classification_fails_when_element_is_arry_with_the_wrong_types
-    assert_raises(ArgumentError){Model.new(:classification, @docs_and_labels, {}, {}, [1, {}] )}
-  end
+      learn_params = { "predfile"  => {}}
 
-  def test_read
-    assert m     = Model.read_from_file('test/assets/model')
-    assert_equal 3877,  m.support_vectors_count
-    assert_equal 39118, m.total_words
-  end
+      assert_raise(ArgumentError) do
+        Model.new(:classification, @docs_and_labels, learn_params, {}, [1, 0.0, 1])
+      end
+    end
 
-  def test_classify
-    m = Model.read_from_file('test/assets/model')
-    assert_kind_of Numeric, m.classify( Document.create(-1, 1, 0, 0,[1.0, 0, 0, 0, 0.5 ].each_with_index.map{|v, i| [i + 1 ,v.to_f]} ) )
-    assert_kind_of Numeric, m.classify( Document.create(-1, 1, 0, 0,[1.0, 0, 0, 0, 0.5 ].each_with_index.map{|v, i| [i + 1,v.to_f]}) )
-    assert_kind_of Numeric, m.classify( Document.create(-1, 1, 0, 0,[1, 0, 0, 0, 0.8, 0, 0 , 0 ].each_with_index.map{|v, i| [i + 1,v.to_f]}) )
-    assert_kind_of Numeric, m.classify( Document.create(-1, 1, 0, 0,[1, 0.5, 0, 0, 0, 0 , 0 ].each_with_index.map{|v, i| [i + 1,v.to_f]}) )
   end
-
 end