mida 0.2.0 → 0.3.0

data/spec/item_spec.rb

@@ -1,584 +1,275 @@
-require_relative 'spec_helper'
-require_relative '../lib/mida'
+require 'spec_helper'
+require 'mida/item'
+require 'mida/vocabulary'
 
-describe Mida::Item, 'when initialized with an itemscope containing just itemprops' do
+describe Mida::Item, 'when initialized with an incomplete itemscope' do
   before do
-    # The first_name element
-    @fn = mock_element('span', {'itemprop' => 'first_name'}, 'Lorry')
-
-    # The last_name element
-    @ln = mock_element('span', {'itemprop' => 'last_name'}, 'Woodman')
-  end
-
-  context 'when there is no itemtype' do
-    before do
-      # The surrounding reviewer itemscope element
-      itemscope_el = mock_element('div', {'itemprop' => 'reviewer', 'itemscope' => true}, nil, [@fn,@ln])
-      @item = Mida::Item.new(itemscope_el)
-    end
-
-    it '#vocabulary should return the correct vocabulary' do
-      @item.vocabulary.should == Mida::Vocabulary::Generic
-    end
-
-    it '#type should return the correct type' do
-      @item.type.should == nil
-    end
-
-    it '#id should return the correct id' do
-      @item.id.should == nil
-    end
-
-    it '#properties should return the correct name/value pairs' do
-      @item.properties.should == {
-        'first_name' => ['Lorry'],
-        'last_name' => ['Woodman']
-      }
-    end
-
-    it '#to_h should return the correct type and properties' do
-      @item.to_h.should == {
-        vocabulary: Mida::Vocabulary::Generic, type: nil, id: nil, properties: {
-          'first_name' => ['Lorry'],
-          'last_name' => ['Woodman']
-        }
-      }
-    end
-  end
-
-  context 'when there is an itemtype' do
-    before do
-      # The surrounding reviewer itemscope element
-      itemscope_el = mock_element('div', {'itemprop' => 'reviewer', 'itemtype' => 'person', 'itemscope' => true}, nil, [@fn,@ln])
-      @item = Mida::Item.new(itemscope_el)
-    end
-
-    it '#vocabulary should return the correct vocabulary' do
-      @item.vocabulary.should == Mida::Vocabulary::Generic
-    end
-
-    it '#type should return the correct type' do
-      @item.type.should == 'person'
-    end
-
-    it '#id should return the correct id' do
-      @item.id.should == nil
-    end
-
-    it '#properties should return the correct name/value pairs' do
-      @item.properties.should == {
-        'first_name' => ['Lorry'],
-        'last_name' => ['Woodman']
-      }
-    end
-
-    it '#to_h should return the correct type and properties' do
-      @item.to_h.should == {
-        vocabulary: Mida::Vocabulary::Generic,
-        type: 'person',
-        id: nil,
-        properties: {
-          'first_name' => ['Lorry'],
-          'last_name' => ['Woodman']
-        }
-      }
-    end
-  end
-end
-
-describe Mida::Item, 'when initialized with an itemscope containing an itemprop with a relative url' do
-  before do
-    @url = mock_element('a', {'itemprop' => 'url', 'href' => 'home/lorry'})
-    itemscope_el = mock_element('div', {'itemscope' => true}, nil, [@url])
-    @item = Mida::Item.new(itemscope_el, "http://example.com")
-  end
-
-  it 'should return the url as an absolute url' do
-    @item.properties['url'].should == ['http://example.com/home/lorry']
-  end
-end
-
-describe Mida::Item, 'when initialized with an itemscope containing itemprops surrounded by a non microdata element' do
-  before do
-    # The first_name element
-    fn = mock_element('span', {'itemprop' => 'first_name'}, 'Lorry')
-
-    # The last_name element
-    ln = mock_element('span', {'itemprop' => 'last_name'}, 'Woodman')
-
-    # A non microdata element surrounding last_name
-    surround = mock_element('span', {}, nil, [ln])
-
-    # The surrounding reviewer itemscope element
-    itemscope_el = mock_element('div', {'itemprop' => 'reviewer',
-                                        'itemtype' => 'person',
-                                        'itemscope' => true},
-                                nil, [fn,surround])
-    @item = Mida::Item.new(itemscope_el)
-  end
-
-  it '#type should return the correct type' do
-    @item.type.should == 'person'
-  end
-
-  it '#vocabulary should return the correct vocabulary' do
-    @item.vocabulary.should == Mida::Vocabulary::Generic
-  end
-
-  it '#id should return the correct id' do
-    @item.id.should == nil
-  end
-
-  it '#properties should return the correct name/value pairs' do
-    @item.properties.should == {
-      'first_name' => ['Lorry'],
-      'last_name' => ['Woodman']
-    }
-  end
-
-  it '#to_h should return the correct type and properties' do
-    @item.to_h.should == {
-      vocabulary: Mida::Vocabulary::Generic,
-      type: 'person',
-      id: nil,
-      properties: {
-        'first_name' => ['Lorry'],
-        'last_name' => ['Woodman']
-      }
-    }
-  end
-
-end
-
-describe Mida::Item, "when initialized with an itemscope containing itemprops
-  who's inner text is surrounded by non-microdata elements" do
-  before do
-    html = '<div itemscope><span itemprop="reviewer">Lorry <em>Woodman</em></span></div>'
-    doc = Nokogiri(html)
-    itemscope = doc.search('./*').first
+    itemscope = mock(Mida::Itemscope)
+    itemscope.stub!(:type).and_return(nil)
+    itemscope.stub!(:id).and_return(nil)
+    itemscope.stub!(:properties).and_return({})
     @item = Mida::Item.new(itemscope)
   end
 
-  it '#vocabulary should return the correct vocabulary' do
-    @item.vocabulary.should == Mida::Vocabulary::Generic
+  it '#type should return the same type as the itemscope' do
+    @item.type.should == nil
   end
 
-  it '#type should return the correct type' do
-    @item.type.should == nil
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::GenericVocabulary
   end
 
-  it '#id should return the correct id' do
+  it '#id should return the same id as the itemscope' do
     @item.id.should == nil
   end
 
-  it '#properties should return the correct name/value pairs' do
-    @item.properties.should == {
-      'reviewer' => ['Lorry Woodman']
-    }
+  it '#properties should return the same properties as the itemscope' do
+    @item.properties.should == {}
   end
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
-      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
-      properties: {
-        'reviewer' => ['Lorry Woodman']
-      }
+      properties: {}
     }
   end
-
 end
 
-describe Mida::Item, "when initialized with an itemscope containing an itemprop
-  nested within another itemprop" do
+describe Mida::Item, 'when initialized with a complete itemscope of an unknown type' do
   before do
-    html = '
-      <div itemscope>
-        <span itemprop="description">The animal is a <span itemprop="colour">green</span> parrot.</span>
-      </div>
-    '
-    doc = Nokogiri(html)
-    itemscope = doc.search('./*').first
+    itemscope = mock(Mida::Itemscope)
+    itemscope.stub!(:type).and_return("book")
+    itemscope.stub!(:id).and_return("urn:isbn:978-1-849510-50-9")
+    itemscope.stub!(:properties).and_return(
+      {'first_name' => ['Lorry'], 'last_name' => ['Woodman']}
+    )
     @item = Mida::Item.new(itemscope)
   end
 
-  it '#vocabulary should return the correct vocabulary' do
-    @item.vocabulary.should == Mida::Vocabulary::Generic
+  it '#type should return the same type as the itemscope' do
+    @item.type.should == "book"
   end
 
-  it '#type should return the correct type' do
-    @item.type.should == nil
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::GenericVocabulary
   end
 
-  it '#id should return the correct id' do
-    @item.id.should == nil
+  it '#id should return the same id as the itemscope' do
+    @item.id.should == "urn:isbn:978-1-849510-50-9"
   end
 
-  it '#properties should return the correct name/value pairs' do
+  it '#properties should return the same properties as the itemscope' do
     @item.properties.should == {
-      'description' => ['The animal is a green parrot.'],
-      'colour' => ['green']
+      'first_name' => ['Lorry'],
+      'last_name' => ['Woodman']
     }
   end
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
-      vocabulary: Mida::Vocabulary::Generic,
-      type: nil,
-      id: nil,
+      type: 'book',
+      id: "urn:isbn:978-1-849510-50-9",
       properties: {
-        'description' => ['The animal is a green parrot.'],
-        'colour' => ['green']
+        'first_name' => ['Lorry'],
+        'last_name' => ['Woodman']
       }
     }
   end
-
 end
 
-describe Mida::Item, 'when initialized with an itemscope containing itemprops with the same name' do
+describe Mida::Item, 'when initialized with an itemscope of a known type' do
   before do
-    # Lemon Sorbet flavour
-    ls_flavour = mock_element('span', {'itemprop' => 'flavour'}, 'Lemon Sorbet')
-
-    # Apricot Sorbet flavour
-    as_flavour = mock_element('span', {'itemprop' => 'flavour'}, 'Apricot Sorbet')
-
-    # Strawberry icecream
-    fruit = mock_element('span', {'itemprop' => 'fruit'}, 'Strawberry')
-
-    # Homemade icecream
-    style = mock_element('span', {'itemprop' => 'style'}, 'Homemade')
-
-    # The surrounding icecreame-type itemscope
-    @sb_flavour = mock_element('div', {'itemprop' => 'flavour',
-                                       'itemtype' => 'icecream-type',
-                                       'itemscope' => true},
-                               nil, [fruit,style])
+    class Person < Mida::Vocabulary
+      itemtype %r{http://example.com/vocab/person}
+      has_one 'name'
+      has_many 'date' do
+        extract Mida::DataType::ISO8601Date, Mida::DataType::Text
+      end
+      has_many 'url'
+    end
 
-    # The surrounding icecreams itemscope element
-    icecreams = mock_element('div', {'itemtype' => 'icecreams',
-                                     'itemscope' => true},
-                             nil, [ls_flavour, as_flavour, @sb_flavour])
-    @item = Mida::Item.new(icecreams)
+    itemscope = mock(Mida::Itemscope)
+    itemscope.stub!(:type).and_return("http://example.com/vocab/person")
+    itemscope.stub!(:id).and_return(nil)
+    itemscope.stub!(:properties).and_return(
+      { 'name' => ['Lorry Woodman'],
+        'date' => ['2nd October 2009', '2009-10-02'],
+        'url' => ['http://example.com/user/lorry']
+      }
+    )
+    @item = Mida::Item.new(itemscope)
   end
 
   it '#vocabulary should return the correct vocabulary' do
-    @item.vocabulary.should == Mida::Vocabulary::Generic
+    @item.vocabulary.should == Person
   end
 
-  it '#type should return the correct type' do
-    @item.type.should == 'icecreams'
+  it 'should return has_one properties as a single value' do
+    @item.properties['name'].should == 'Lorry Woodman'
   end
 
-  it '#id should return the correct id' do
-    @item.id.should == nil
+  it 'should return has_many properties as an array' do
+    @item.properties['url'].should == ['http://example.com/user/lorry']
   end
 
-  it '#properties should return the correct name/value pairs' do
-    @item.properties.should == {
-      'flavour' => [
-        'Lemon Sorbet',
-        'Apricot Sorbet',
-        Mida::Item.new(@sb_flavour)
-      ]
-    }
+  it 'should reject datatypes that are not valid' do
+    @item.properties['date'][0].should == '2nd October 2009'
   end
 
-  it '#to_h should return the correct type and properties' do
-    @item.to_h.should == {
-      vocabulary: Mida::Vocabulary::Generic,
-      type: 'icecreams',
-      id: nil,
-      properties: {
-        'flavour' => [
-          'Lemon Sorbet',
-          'Apricot Sorbet',
-          { vocabulary: Mida::Vocabulary::Generic,
-            type: 'icecream-type',
-            id: nil,
-            properties: {
-              'fruit' => ['Strawberry'],
-              'style' => ['Homemade']
-            }
-          }
-        ]
-      }
-    }
+  it 'should accept datatypes that are valid' do
+    @item.properties['date'][1].should == Date.iso8601('2009-10-02')
   end
 
-end
-
-describe Mida::Item, 'when initialized with an itemscope containing itemrefs' do
-
-  before do
-
-    name = mock_element('span', {'itemprop' => 'name'}, 'Amanda')
-    name_p = mock_element('p', {'id' => 'a'}, nil, [name])
-
-    band_name = mock_element('span', {'itemprop' => 'band_name'}, 'Jazz Band')
-    band_size = mock_element('span', {'itemprop' => 'band_size'}, '12')
-    band_div = mock_element('div', {'id' => 'c'}, nil, [band_name, band_size])
-    @empty_band_div = mock_element('div', {'id' => 'b',
-                                          'itemprop' => 'band',
-                                          'itemref' => 'c',
-                                          'itemscope' => true},
-                                  nil, [],
-                                  {'c' => band_div})
-
-
-    age = mock_element('span', {'itemprop' => 'age'}, '30')
-    age_div = mock_element('div', {'itemref' => 'a b',
-                                   'itemscope' => true},
-                           nil, [age],
-                           {'a' => name_p, 'b' => @empty_band_div})
-
-    @item = Mida::Item.new(age_div)
+  it 'should reject datatypes that are not valid' do
+    @item.properties['date'][1].should == Date.iso8601('2009-10-02')
   end
 
-  it '#vocabulary should return the correct vocabulary' do
-    @item.vocabulary.should == Mida::Vocabulary::Generic
-  end
-
-  it '#type should return the correct type' do
-    @item.type.should == nil
-  end
-
-  it '#id should return the correct id' do
-    @item.id.should == nil
-  end
-
-  it '#properties should return the correct name/value pairs' do
+  it '#properties should return the same properties as the itemscope' do
     @item.properties.should == {
-      'age' => ['30'],
-      'name' => ['Amanda'],
-      'band' => [Mida::Item.new(@empty_band_div)]
+      'name' => 'Lorry Woodman',
+      'date' => ['2nd October 2009', Date.iso8601('2009-10-02')],
+      'url' => ['http://example.com/user/lorry']
     }
   end
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
-      vocabulary: Mida::Vocabulary::Generic,
-      type: nil,
+      type: 'http://example.com/vocab/person',
       id: nil,
       properties: {
-        'age' => ['30'],
-        'name' => ['Amanda'],
-        'band' => [{
-          vocabulary: Mida::Vocabulary::Generic,
-          type: nil,
-          id: nil,
-          properties: {
-            'band_name' => ['Jazz Band'],
-            'band_size' => ['12']
-          }
-        }]
+        'name' => 'Lorry Woodman',
+        'date' => ['2nd October 2009', Date.iso8601('2009-10-02')],
+        'url' => ['http://example.com/user/lorry']
       }
     }
   end
 
 end
 
-describe Mida::Item, 'when initialized with an itemscope containing an itemid' do
-
+describe Mida::Item, 'when initialized with an itemscope of a known type that does not fully match vocabulary' do
   before do
+    # Make sure the class is redefined afresh to make sure that
+    # inherited() hook is called
+    Mida::Vocabulary.unregister(Person)
+    Object.send(:remove_const, :Person)
+    class Person < Mida::Vocabulary
+      itemtype %r{http://example.com/vocab/person}
+      has_one 'name', 'tel'
+      has_many 'url', 'city'
+    end
 
-    title = mock_element('span', {'itemprop' => 'title'}, 'Hacking Vim 7.2')
-    author = mock_element('span', {'itemprop' => 'author'}, 'Kim Schulz')
-    book = mock_element('div', {
-      'itemtype' => 'book',
-      'itemid' => 'urn:isbn:978-1-849510-50-9',
-      'itemscope' => true},
-      nil, [title,author])
-
-    @item = Mida::Item.new(book)
+    itemscope = mock(Mida::Itemscope)
+    itemscope.stub!(:type).and_return("http://example.com/vocab/person")
+    itemscope.stub!(:id).and_return(nil)
+    itemscope.stub!(:properties).and_return(
+      { 'name' => ['Lorry Woodman'],
+        'tel' => ['000004847582', '111111857485'],
+        'url' => ['http://example.com/user/lorry'],
+        'city' => ['Bristol']
+      }
+    )
+    @item = Mida::Item.new(itemscope)
   end
 
   it '#vocabulary should return the correct vocabulary' do
-    @item.vocabulary.should == Mida::Vocabulary::Generic
-  end
-
-  it '#type should return the correct type' do
-    @item.type.should == 'book'
-  end
-
-  it '#id should return the correct id' do
-    @item.id.should == 'urn:isbn:978-1-849510-50-9'
+    @item.vocabulary.should == Person
   end
 
-  it '#properties should return the correct name/value pairs' do
-    @item.properties.should == {
-      'title' => ['Hacking Vim 7.2'],
-      'author' => ['Kim Schulz']
-    }
+  it 'should not keep properties that have too many values' do
+    @item.properties.should_not have_key('tel')
   end
 
-  it '#to_h should return the correct type and properties' do
-    @item.to_h.should == {
-      vocabulary: Mida::Vocabulary::Generic,
-      type: 'book',
-      id: 'urn:isbn:978-1-849510-50-9',
-      properties: {
-        'title' => ['Hacking Vim 7.2'],
-        'author' => ['Kim Schulz']
-      }
-    }
+  it 'should keep have_many properties even if they have only one value' do
+    @item.properties.should have_key('city')
   end
 
 end
 
-describe Mida::Item, 'when initialized with an itemscope containing itemscopes as properties nested two deep' do
+describe Mida::Item, 'when initialized with an itemscope containing another correct itemscope' do
   before do
+    class Tel < Mida::Vocabulary
+      itemtype %r{http://example.com/vocab/tel}
+      has_one 'dial_code', 'number'
+    end
 
-    # The name of the item reviewed
-    @item_name = mock_element('span', {'itemprop' => 'item_name'}, 'Acme Anvil')
-
-    # The rating of the item
-    @rating = mock_element('span', {'itemprop' => 'rating'}, '5')
-
-    # The first_name
-    @fn = mock_element('span', {'itemprop' => 'first_name'}, 'Lorry')
-
-    # The last_name
-    @ln = mock_element('span', {'itemprop' => 'last_name'}, 'Woodman')
-
-    # The organization name
-    @org_name = mock_element('span', {'itemprop' => 'name'}, 'Acme')
-
-    # The surrounding organization itemscope
-    @org_el = mock_element('div', {'itemprop' => 'represents',
-                                   'itemtype' => 'organization',
-                                   'itemscope' => true}, nil, [@org_name])
-
-    # The surrounding reviewer itemscope
-    @reviewer_el = mock_element('div', {'itemprop' => 'reviewer',
-                                        'itemtype' => 'person',
-                                        'itemscope' => true},
-                                nil, [@fn,@ln, @org_el])
-
-    # The surrounding reviewer itemscope
-    @review_el = mock_element('div', {'itemtype' => 'review', 'itemscope' => true}, nil, [@item_name, @rating, @reviewer_el])
-
-    @item = Mida::Item.new(@review_el)
-
-  end
+    class Person < Mida::Vocabulary
+      itemtype %r{http://example.com/vocab/person}
+      has_one 'name'
+      has_many 'tel' do
+        extract Tel, Mida::DataType::Text
+      end
+    end
 
-  before do
+    tel_itemscope = mock(Mida::Itemscope)
+    tel_itemscope.stub!(:kind_of?).any_number_of_times.with(Mida::Itemscope).and_return(true)
+    tel_itemscope.stub!(:type).and_return("http://example.com/vocab/tel")
+    tel_itemscope.stub!(:id).and_return(nil)
+    tel_itemscope.stub!(:properties).and_return(
+      { 'dial_code' => ['0248583'],
+        'number' => ['000004847582'],
+      }
+    )
+    person_itemscope = mock(Mida::Itemscope)
+    person_itemscope.stub!(:type).and_return("http://example.com/vocab/person")
+    person_itemscope.stub!(:id).and_return(nil)
+    person_itemscope.stub!(:properties).and_return(
+      { 'name' => ['Lorry Woodman'],
+        'tel' => ['000004847582', tel_itemscope],
+      }
+    )
+    @item = Mida::Item.new(person_itemscope)
   end
 
   it '#vocabulary should return the correct vocabulary' do
-    @item.vocabulary.should == Mida::Vocabulary::Generic
-  end
-
-  it '#type should return the correct type' do
-    @item.type.should == 'review'
-  end
-
-  it '#id should return the correct id' do
-    @item.id.should == nil
+    @item.vocabulary.should == Person
   end
 
-  it '#properties should return the correct name/value pairs' do
-    @item.properties.should == {
-      'item_name' => ['Acme Anvil'],
-      'rating' => ['5'],
-      'reviewer' => [Mida::Item.new(@reviewer_el)]
+  it 'should validate and convert the nested itemscope' do
+    @item.properties['tel'][1].vocabulary.should == Tel
+    @item.properties['tel'][1].properties.should == {
+      'dial_code' => '0248583',
+      'number' => '000004847582',
     }
   end
 
-  it '#to_h should return the correct type and properties' do
-    @item.to_h.should == {
-      vocabulary: Mida::Vocabulary::Generic,
-      type: 'review',
-      id: nil,
-      properties: {
-        'item_name' => ['Acme Anvil'],
-        'rating' => ['5'],
-        'reviewer' => [{
-          vocabulary: Mida::Vocabulary::Generic,
-          type: 'person',
-          id: nil,
-          properties: {
-            'first_name' => ['Lorry'],
-            'last_name' => ['Woodman'],
-            'represents' => [{
-              vocabulary: Mida::Vocabulary::Generic,
-              type: 'organization',
-              id: nil,
-              properties: {
-                'name' => ['Acme']
-              }
-           }]
-          }
-        }]
-      }
-    }
+  it 'should accept the text tel' do
+    @item.properties['tel'][0].should == '000004847582'
   end
+
 end
 
-describe Mida::Item, 'when initialized with an itemscope that matches a non-generic registered vocabulary' do
+describe Mida::Item, 'when initialized with an itemscope containing another invalid itemscope' do
   before do
-
-    class Colour < Mida::VocabularyDesc
-      itemtype %r{http://example.com/vocab/colour}
-      has_one 'red', 'green', 'blue'
-    end
-    Mida::Vocabulary.register(Colour)
-
-    class Person < Mida::VocabularyDesc
+    class Person < Mida::Vocabulary
       itemtype %r{http://example.com/vocab/person}
       has_one 'name'
-      has_one 'url'
-      has_many 'limbs'
-      has_many 'favourite-colours' do
-        types Colour
-      end
+      has_many 'tel'
     end
-    Mida::Vocabulary.register(Person)
-
-    red = mock_element('span', {'itemprop' => 'red'}, '0xFF')
-    green = mock_element('span', {'itemprop' => 'green'}, '0x00')
-    blue = mock_element('span', {'itemprop' => 'blue'}, '0xFF')
-    purple = mock_element('div', {'itemscope' => true,
-                                  'itemtype' => 'http://example.com/vocab/colour',
-                                  'itemprop' => 'favourite-colours'},
-                                 nil, [red, green, blue])
-    orange = mock_element('span', {'itemprop' => 'favourite-colours'}, 'Orange')
-
-    name1 = mock_element('span', {'itemprop' => 'name'}, 'Lawrence Woodman')
-    name2 = mock_element('span', {'itemprop' => 'name'}, 'Lorry Woodman')
-    url = mock_element('a', {'itemprop' => 'url', 'href' => 'http://example.com/myhomepage'})
-    arm = mock_element('span', {'itemprop' => 'limbs'}, 'Arm')
-    leg = mock_element('span', {'itemprop' => 'limbs'}, 'Leg')
-    robert_wilson = mock_element('span', {'itemprop' => 'favourite-author'}, 'Robert Wilson')
-    itemscope_el = mock_element('div', {'itemscope' => true,
-                                        'itemtype' =>'http://example.com/vocab/person'
-                                       }, nil, [name1, name2, url, arm, leg, purple, orange, robert_wilson])
-    @item = Mida::Item.new(itemscope_el, "http://example.com")
-  end
-
-  it '#vocabulary should return the correct vocabulary' do
-    @item.vocabulary.should == Person
-  end
-
-  it 'should reject properties that have multiple values if has_one specified' do
-    @item.properties.should_not have_key('name')
-  end
-
-  it 'should accept properties that have a single value if has_one specified' do
-    @item.properties['url'].should == ['http://example.com/myhomepage']
-  end
 
-  it 'should accept properties that have a many values if has_many specified' do
-    @item.properties['limbs'].should == ['Arm', 'Leg']
+    tel_itemscope = mock(Mida::Itemscope)
+    tel_itemscope.stub!(:kind_of?).any_number_of_times.with(Mida::Itemscope).and_return(true)
+    tel_itemscope.stub!(:type).and_return("http://example.com/vocab/tel")
+    tel_itemscope.stub!(:id).and_return(nil)
+    tel_itemscope.stub!(:properties).and_return(
+      { 'dial_code' => ['0248583'],
+        'number' => ['000004847582'],
+      }
+    )
+    person_itemscope = mock(Mida::Itemscope)
+    person_itemscope.stub!(:type).and_return("http://example.com/vocab/person")
+    person_itemscope.stub!(:id).and_return(nil)
+    person_itemscope.stub!(:properties).and_return(
+      { 'name' => ['Lorry Woodman'],
+        'tel' => ['000004847582', tel_itemscope],
+      }
+    )
+    @item = Mida::Item.new(person_itemscope)
   end
 
-  it 'should register properties using the specified types' do
-    @item.properties['favourite-colours'].size.should == 1
-    @item.properties['favourite-colours'].first.vocabulary.should == Colour
+  it 'should only accept values of the correct type' do
+    @item.properties['tel'].size.should == 1
+    @item.properties['tel'][0].should == '000004847582'
   end
 
-  it 'should reject properties that are not specified' do
-    @item.properties.should_not have_key('favourite-author')
-  end
 end