spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/test/unit/test_datamapper_content.rb

@@ -2,7 +2,7 @@
 
 require File.expand_path('../../test_helper', __FILE__)
 
-class DataMapperContentTest < MiniTest::Spec
+describe "DataMapperContent" do
 
   class NameMap
     def initialize(*args)
@@ -17,7 +17,7 @@ class DataMapperContentTest < MiniTest::Spec
     end
   end
 
-  def setup
+  before do
     @expected_columns = DB[:content].columns
     @database = ::Sequel.mock(autoid: 1)
     @database.columns = @expected_columns
@@ -27,188 +27,186 @@ class DataMapperContentTest < MiniTest::Spec
     Object.const_set(:Content, content_class)
   end
 
-  def teardown
+  after do
     Object.send :remove_const, :Content rescue nil
   end
 
-  context "Content" do
-    should "be defined as a top-level constant" do
+    it  "be defined as a top-level constant" do
       ::Content.must_be_instance_of Class
     end
 
-    should "serialize the correct columns" do
-      ::Content.serialized_columns.should == [:field_store, :entry_store, :box_store, :serialized_modifications]
+    it  "serialize the correct columns" do
+      ::Content.serialized_columns.must_equal [:field_store, :entry_store, :box_store, :serialized_modifications]
     end
 
-    should "search without type filters" do
+    it  "search without type filters" do
       @database.sqls # clear sql log
       ::Content.all
-      @database.sqls.should == [
+      @database.sqls.must_equal [
         "SELECT * FROM content"
       ]
     end
 
-    should "have a 'Page' superclass definition" do
+    it  "have a 'Page' superclass definition" do
       ::Content::Page.must_be_instance_of Class
     end
 
-    should "have a 'Piece' superclass definition" do
+    it  "have a 'Piece' superclass definition" do
       ::Content::Piece.must_be_instance_of Class
     end
 
-    should "use the mapper's cache for retrieval of the site root" do
+    it  "use the mapper's cache for retrieval of the site root" do
       @database.sqls # clear sql log
       a = b = nil
       ::Content.with_editable do
         a = ::Content.root
         b = ::Content.root
       end
-      @database.sqls.should == [
+      @database.sqls.must_equal [
         "SELECT * FROM content WHERE (path = '/') LIMIT 1"
       ]
     end
 
-    should "use the mapper's cache for retrieval of artibary paths" do
+    it  "use the mapper's cache for retrieval of artibary paths" do
       @database.sqls # clear sql log
       a = b = nil
       ::Content.with_editable do
         a = ::Content.path("/this")
         b = ::Content.path("/this")
       end
-      @database.sqls.should == [
+      @database.sqls.must_equal [
         "SELECT * FROM content WHERE (path = '/this') LIMIT 1"
       ]
     end
 
-    should "use the mapper's cache for retrieval via UID" do
+    it  "use the mapper's cache for retrieval via UID" do
       @database.sqls # clear sql log
       a = b = nil
       ::Content.with_editable do
         a = ::Content.uid("fish")
         b = ::Content.uid("fish")
       end
-      @database.sqls.should == [
+      @database.sqls.must_equal [
         "SELECT * FROM content WHERE (uid = 'fish') LIMIT 1"
       ]
     end
 
-    context "Pages" do
-      setup do
+    describe "Pages" do
+      before do
         page_class = Class.new(::Content::Page)
         Object.const_set(:Page, page_class)
         Object.const_set(:P1, Class.new(page_class))
         Object.const_set(:P2, Class.new(page_class))
       end
 
-      teardown do
+      after do
         Object.send :remove_const, :Page rescue nil
         Object.send :remove_const, :P1   rescue nil
         Object.send :remove_const, :P2   rescue nil
       end
 
-      should "include all page classes when searching from Page base class" do
+      it  "include all page classes when searching from Page base class" do
         @database.sqls # clear sql log
         ::Content::Page.all
-        @database.sqls.should == [
+        @database.sqls.must_equal [
           "SELECT * FROM content WHERE (type_sid IN ('Page', 'P1', 'P2'))"
         ]
       end
 
-      should "limit searches to a single class for all other page types" do
+      it  "limit searches to a single class for all other page types" do
         @database.sqls # clear sql log
         ::Page.all
         ::P1.all
         ::P2.all
-        @database.sqls.should == [
+        @database.sqls.must_equal [
           "SELECT * FROM content WHERE (type_sid IN ('Page'))",
           "SELECT * FROM content WHERE (type_sid IN ('P1'))",
           "SELECT * FROM content WHERE (type_sid IN ('P2'))"
         ]
       end
 
-      should "keep a reference to their top-level content model" do
-        ::Content::Page.content_model.should == ::Content
-        ::Page.content_model.should == ::Content
-        ::P1.content_model.should == ::Content
-        ::P2.content_model.should == ::Content
+      it  "keep a reference to their top-level content model" do
+        ::Content::Page.content_model.must_equal ::Content
+        ::Page.content_model.must_equal ::Content
+        ::P1.content_model.must_equal ::Content
+        ::P2.content_model.must_equal ::Content
       end
 
-      should "provide a class method to return all page instances" do
+      it  "provide a class method to return all page instances" do
         @database.sqls # clear sql log
         P2.pages
-        @database.sqls.should == [
+        @database.sqls.must_equal [
           "SELECT * FROM content WHERE (type_sid IN ('Page', 'P1', 'P2'))"
         ]
       end
 
-      should "provide a class method to return the root of the content hierarchy" do
+      it  "provide a class method to return the root of the content hierarchy" do
         @database.sqls # clear sql log
         P2.root
-        @database.sqls.should == [
+        @database.sqls.must_equal [
           "SELECT * FROM content WHERE (path = '/') LIMIT 1"
         ]
       end
 
-      should "allow for defining an order" do
+      it  "allow for defining an order" do
         @database.sqls # clear sql log
         P2.order("label").all
-        @database.sqls.should == [
+        @database.sqls.must_equal [
           "SELECT * FROM content WHERE (type_sid IN ('P2')) ORDER BY 'label'"
         ]
       end
 
-      should "allow for limiting the columns selected" do
+      it  "allow for limiting the columns selected" do
         @database.sqls # clear sql log
         P2.select("id").all
-        @database.sqls.should == [
+        @database.sqls.must_equal [
           "SELECT 'id' FROM content WHERE (type_sid IN ('P2'))"
         ]
       end
     end
 
-    context "Pieces" do
-      setup do
+    describe "Pieces" do
+      before do
         klass = Class.new(::Content::Piece)
         Object.const_set(:Piece, klass)
         Object.const_set(:P1, Class.new(klass))
         Object.const_set(:P2, Class.new(klass))
       end
 
-      teardown do
+      after do
         Object.send :remove_const, :Piece rescue nil
         Object.send :remove_const, :P1   rescue nil
         Object.send :remove_const, :P2   rescue nil
       end
 
-      should "include all page classes when searching from Page base class" do
+      it  "include all page classes when searching from Page base class" do
         @database.sqls # clear sql log
         ::Content::Piece.all
-        @database.sqls.should == [
+        @database.sqls.must_equal [
           "SELECT * FROM content WHERE (type_sid IN ('Piece', 'P1', 'P2'))"
         ]
       end
 
-      should "limit searches to a single class for all other page types" do
+      it  "limit searches to a single class for all other page types" do
         @database.sqls # clear sql log
         ::Piece.all
         ::P1.all
         ::P2.all
-        @database.sqls.should == [
+        @database.sqls.must_equal [
           "SELECT * FROM content WHERE (type_sid IN ('Piece'))",
           "SELECT * FROM content WHERE (type_sid IN ('P1'))",
           "SELECT * FROM content WHERE (type_sid IN ('P2'))"
         ]
       end
 
-      should "keep a reference to their top-level content model" do
-        ::Content::Piece.content_model.should == ::Content
-        ::Piece.content_model.should == ::Content
-        ::P1.content_model.should == ::Content
-        ::P2.content_model.should == ::Content
+      it  "keep a reference to their top-level content model" do
+        ::Content::Piece.content_model.must_equal ::Content
+        ::Piece.content_model.must_equal ::Content
+        ::P1.content_model.must_equal ::Content
+        ::P2.content_model.must_equal ::Content
         p = P2.new
-        p.content_model.should == ::Content
+        p.content_model.must_equal ::Content
       end
 
     end
-  end
 end

data/test/unit/test_extensions.rb

@@ -3,43 +3,43 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 
-class ExtensionsTest < MiniTest::Spec
-  context "String" do
-    should "create paths with String#/" do
-      ("this" / "that").should == "this/that"
-      ("/this" / "/that").should == "/this/that"
+describe "Extensions" do
+  describe "String" do
+    it  "create paths with String#/" do
+      ("this" / "that").must_equal "this/that"
+      ("/this" / "/that").must_equal "/this/that"
     end
 
-    should "override the | method to return the argument if empty" do
-      ("" | "that").should == "that"
-      ("this" | "that").should == "this"
+    it  "override the | method to return the argument if empty" do
+      ("" | "that").must_equal "that"
+      ("this" | "that").must_equal "this"
     end
 
-    should "override the or method to return the argument if empty" do
-      ("".or("that")).should == "that"
-      ("this".or("that")).should == "this"
+    it  "override the or method to return the argument if empty" do
+      ("".or("that")).must_equal "that"
+      ("this".or("that")).must_equal "this"
     end
 
-    should "return self for #value" do
-      "this".value.should == "this"
-      "this".value(:html).should == "this"
-      "this".value(:smsx).should == "this"
+    it  "return self for #value" do
+      "this".value.must_equal "this"
+      "this".value(:html).must_equal "this"
+      "this".value(:smsx).must_equal "this"
     end
   end
 
-  context "Nil" do
-    should "always return the argument for the slash switch" do
-      (nil / "something").should == "something"
+  describe "Nil" do
+    it  "always return the argument for the slash switch" do
+      (nil / "something").must_equal "something"
     end
-    should "always return the argument for the #or switch" do
-      (nil.or("something")).should == "something"
+    it  "always return the argument for the #or switch" do
+      (nil.or("something")).must_equal "something"
     end
   end
 
-  context "Enumerable" do
-    should "correctly slice_between elements" do
+  describe "Enumerable" do
+    it  "correctly slice_between elements" do
       result = ["js", "coffee", "coffee", "js", "coffee"].slice_between { |prev, current| prev != current }.to_a
-      result.should == [["js"], ["coffee", "coffee"], ["js"], ["coffee"]]
+      result.must_equal [["js"], ["coffee", "coffee"], ["js"], ["coffee"]]
     end
   end
 end