occi-core 4.1.3 → 4.2.0

data/spec/occi/core/category_spec.rb

@@ -2,33 +2,209 @@ module Occi
   module Core
     describe Category do
 
-      describe '.new' do
+      let(:category) { Category.new }
+      let(:category_scheme) { Category.new 'http://example.org/test#', 'category' }
+      let(:category_term) { Category.new 'http://schemas.ogf.org/occi/core#', 'testcat' }
+      let(:category_scheme_term) { Category.new *'http://schemas.ogf.org/occi/test#category1'.split('#') }
 
-        it 'instantiates a new Category' do
-          category = Category.new
-          category.scheme.should == 'http://schemas.ogf.org/occi/core#'
-          category.term.should == 'category'
-          category.title.should be_nil
-          category.attributes.should be_kind_of Occi::Core::Attributes
-          category.attributes.should be_empty
+      context '#new' do
+
+        it 'with defaults' do
+          expect { Category.new }.not_to raise_error
+        end
+
+        it 'fails without scheme' do
+          expect { Category.new nil }.to raise_error(ArgumentError)
+        end
+
+        it 'fails without term' do
+          expect { Category.new 'scheme', nil }.to raise_error(ArgumentError)
+        end
+
+        it 'passes without attributes' do
+          expect { Category.new 'scheme', 'term', nil, nil }.not_to raise_error
+        end
+
+      end
+
+      context 'instance attributes' do
+
+        it 'default scheme is OGF OCCI Core' do
+          expect(category.scheme).to eq 'http://schemas.ogf.org/occi/core#'
         end
 
-        it 'instantiates a new Category and ensures that the scheme ends with a #' do
-          category = Category.new *'http://schemas.ogf.org/occi/core#category'.split('#')
-          category.scheme.should == 'http://schemas.ogf.org/occi/core#'
-          category.term.should == 'category'
-          category.title.should be_nil
-          category.attributes.should be_kind_of Occi::Core::Attributes
-          category.attributes.should be_empty
+        it 'default term is "category"' do
+          expect(category.term).to eq 'category'
+        end
+
+        it 'default title is nil' do
+          expect(category.title).to be_nil
+        end
+
+        it 'default attributes are Occi::Core::Attributes' do
+          expect(category.attributes).to be_kind_of Occi::Core::Attributes
+        end
+
+        it 'default attributes are empty' do
+          expect(category.attributes).to be_empty
+        end
+
+        it 'scheme always ends with a #' do
+          expect(category_scheme_term.scheme).to eq 'http://schemas.ogf.org/occi/test#'
+        end
+
+        it 'term is always after the #' do
+          expect(category_scheme_term.term).to eq 'category1'
         end
 
       end
 
-      describe '#type_identifier' do
+      context '#type_identifier' do
 
         it 'returns the type identifier of the category' do
-          category = Category.new
-          category.type_identifier.should == 'http://schemas.ogf.org/occi/core#category'
+          expect(category.type_identifier).to eq 'http://schemas.ogf.org/occi/core#category'
+        end
+
+      end
+
+      context '#==' do
+
+        it 'matches the same instance' do
+          expect(category).to eq category
+        end
+
+        it 'matches a clone' do
+          expect(category).to eq category.clone
+        end
+
+        it 'matches with a different title' do
+          changed_clone = category.clone
+          changed_clone.title = 'newtitle'
+
+          expect(category).to eq changed_clone
+        end
+
+        it 'matches with different attributes' do
+          changed_clone = category.clone
+          changed_clone.attributes = Occi::Core::Attributes.new({ "id" => '123123' })
+
+          expect(category).to eq changed_clone
+        end
+
+        it 'does not match a nil' do
+          expect(category).not_to eq nil
+        end
+
+        it 'does not match with a different scheme' do
+          expect(category).not_to eq category_scheme
+        end
+
+        it 'does not match with a different term' do
+          expect(category).not_to eq category_term
+        end
+
+        it 'does not match with a different scheme and term' do
+          expect(category).not_to eq category_scheme_term
+        end
+
+      end
+
+      context '#eql?' do
+
+        it 'matches the same instance' do
+          expect(category).to eql category
+        end
+
+        it 'matches a clone' do
+          expect(category).to eql category.clone
+        end
+
+        it 'matches with a different title' do
+          changed_clone = category.clone
+          changed_clone.title = 'newtitle'
+
+          expect(category).to eql changed_clone
+        end
+
+        it 'matches with different attributes' do
+          changed_clone = category.clone
+          changed_clone.attributes = Occi::Core::Attributes.new({ "id" => '123123' })
+
+          expect(category).to eql changed_clone
+        end
+
+        it 'does not match a nil' do
+          expect(category).not_to eql nil
+        end
+
+        it 'does not match with a different scheme' do
+          expect(category).not_to eql category_scheme
+        end
+
+        it 'does not match with a different term' do
+          expect(category).not_to eql category_term
+        end
+
+        it 'does not match with a different scheme and term' do
+          expect(category).not_to eql category_scheme_term
+        end
+
+      end
+
+      context '#equal?' do
+
+        it 'matches the same instance' do
+          expect(category).to equal category
+        end
+
+        it 'does not match clones' do
+          expect(category).not_to equal category.clone
+        end
+
+      end
+
+      context '#hash' do
+
+        it 'matches for clones' do
+          expect(category.hash).to eq category.clone.hash
+        end
+
+        it 'matches for the same instance' do
+          expect(category.hash).to eq category.hash
+        end
+
+        it 'does not match when term is different' do
+          expect(category.hash).not_to eq category_term.hash
+        end
+
+        it 'does not match when scheme is different' do
+          expect(category.hash).not_to eq category_scheme.hash
+        end
+
+        it 'does not match when scheme and term are different' do
+          expect(category.hash).not_to eq category_scheme_term
+        end
+
+      end
+
+      context '#empty?' do
+
+        it 'returns false for a new instance with defaults' do
+          expect(category.empty?).to be_false
+        end
+
+        it 'returns true for an instance without a term' do
+          cat = category.clone
+          cat.term = nil
+
+          expect(cat.empty?).to be_true
+        end
+
+        it 'returns true for an instance without a scheme' do
+          cat = category.clone
+          cat.scheme = nil
+
+          expect(cat.empty?).to be_true
         end
 
       end

data/spec/occi/core/entities_spec.rb

@@ -0,0 +1,96 @@
+module Occi
+  module Core
+    describe Entities do
+      let(:entities){ Occi::Core::Entities.new }
+      let(:entity1){ entity1 = Occi::Core::Entity.new
+        entity1.id = "e1testid"
+        entity1 }
+      let(:entity2){ entity2 = Occi::Core::Entity.new 'http://example.org/test/schema#entity2'
+        entity2.id = "e2testid"
+        entity2 }
+      let(:testaction){ Occi::Core::Action.new scheme='http://schemas.ogf.org/occi/core/entity/action#', term='testaction', title='testaction action' }
+
+      context 'populating' do
+
+        it 'is created empty' do
+          expect(entities.count).to eq 0
+        end
+        it 'gets entity Nos. right, 1' do
+          entities << entity1
+          expect(entities.count).to eq 1
+        end
+        it 'gets entity Nos. right, 2' do
+          entities << entity1
+          entities << entity2
+          expect(entities.count).to eq 2
+        end
+        it 'gets correctly-typed elements' do
+          entities << entity1
+          entities << entity2
+          expect(entities.first).to be_an_instance_of(Occi::Core::Entity)
+        end
+      end
+
+      context '#model' do
+        it 'has no model by default' do
+          expect(entities.model).to be nil
+        end
+        it 'can be assigned model' do
+          modl = Occi::Model.new
+          entities.model = modl
+          expect(entities.model).to eql modl
+        end
+        it 'uses the assigned model for new members' do
+          modl = Occi::Model.new
+          entities.model = modl
+          entities << entity1
+          expect(entities.first.model).to eql modl
+        end
+        it 'uses the assigned model for existing members' do
+          entities << entity1
+          modl = Occi::Model.new
+          entities.model = modl
+          expect(entities.first.model).to eql modl
+        end
+        it 'does not use unassigned model' do
+          modl = Occi::Model.new
+          entities << entity1
+          expect(entities.first.model).to_not eql modl
+        end
+      end
+
+      context '#create' do
+        it 'creates a new element' do
+          entities.create
+          expect(entities.first).to be_instance_of(Occi::Core::Entity)
+        end
+        it 'accepts argument' do
+          entities.create 'http://example.com/testnamespace#test'
+          expect(entities.first).to be_kind_of 'Com::Example::Testnamespace::Test'.constantize
+        end
+      end
+
+      context '#join' do
+        it 'joins elements correctly' do
+          entities << entity1
+          entities << entity2
+          expect(entities.join('|')).to eq '/entity/e1testid|/entity2/e2testid'
+        end
+      end
+
+      context '#as_json' do
+        it 'renders elements with various attributes' do
+          entity2.actions << testaction
+          entities << entity1
+          entities << entity2
+          expected = []
+          hash=Hashie::Mash.new JSON.parse('{"kind":"http://schemas.ogf.org/occi/core#entity","attributes":{"occi":{"core":{"id":"e1testid"}}},"id":"e1testid"}')
+          hash2= Hashie::Mash.new JSON.parse('{"kind":"http://example.org/test/schema#entity2","actions":[{"scheme":"http://schemas.ogf.org/occi/core/entity/action#","term":"testaction","title":"testaction action","attributes":{}}],"attributes":{"occi":{"core":{"id":"e2testid"}}},"id":"e2testid"}')
+          expected << hash
+          expected << hash2
+          expect(entities.as_json).to eql expected
+        end
+      end
+    end
+  end
+end

data/spec/occi/core/entity_spec.rb

@@ -1,44 +1,333 @@
 module Occi
   module Core
     describe Entity do
+      let(:entity){
+        entity = Occi::Core::Entity.new
+        entity.id = 'baf1'
+        entity
+      }
+      let(:testaction){ Occi::Core::Action.new scheme='http://schemas.ogf.org/occi/core/entity/action#', term='testaction', title='testaction action' }
 
       it "initializes itself successfully" do
-        entity = Occi::Core::Entity.new
-        entity.should be_kind_of Occi::Core::Entity
+        expect(entity).to be_kind_of Occi::Core::Entity
       end
 
-      it "initializes a subclass successfully using a type identifier" do
-        type_identifier = 'http://example.com/testnamespace#test'
-        entity = Occi::Core::Entity.new type_identifier
-        entity.should be_kind_of 'Com::Example::Testnamespace::Test'.constantize
-        entity.kind.type_identifier.should == type_identifier
-        entity.kind.related.first.should == Occi::Core::Entity.kind
+      context 'initializiation of a subclass using a type identifier' do
+        let(:type_identifier){ 'http://example.com/testnamespace#test' }
+        let(:typed_entity){ Occi::Core::Entity.new type_identifier }
+
+        it 'has the correct kind' do
+          expect(typed_entity).to be_kind_of 'Com::Example::Testnamespace::Test'.constantize
+        end
+
+        it 'uses the right identifier' do
+          expect(typed_entity.kind.type_identifier).to eq type_identifier
+        end
+
+        it 'relates to Entity' do
+          expect(typed_entity.kind.related.first).to eq Occi::Core::Entity.kind
+        end
       end
 
-      it "initializes a subclass successfully using an OCCI Kind" do
-        kind = Occi::Core::Resource.kind
-        entity = Occi::Core::Entity.new kind
-        entity.should be_kind_of Occi::Core::Resource
-        entity.kind.type_identifier.should == Occi::Core::Resource.type_identifier
-        entity.kind.related.first.should == Occi::Core::Entity.kind
+      context "initialization of a subclass using an OCCI Kind" do
+        let(:kind){ Occi::Core::Resource.kind }
+        let(:kind_entity){ Occi::Core::Entity.new kind }
+
+        it 'has the correct kind' do
+          expect(kind_entity).to be_kind_of Occi::Core::Resource
+        end
+
+        it 'uses the right identifier' do
+          expect(kind_entity.kind.type_identifier).to eq Occi::Core::Resource.type_identifier
+        end
+
+        it 'relates to Entity' do
+          expect(kind_entity.kind.related.first).to eq Occi::Core::Entity.kind
+        end
       end
 
-      it "converts mixin type identifiers to objects if a mixin is added to the entities mixins" do
-        mixin = 'http://example.com/mynamespace#mymixin'
-        entity = Occi::Core::Entity.new
-        entity.mixins << mixin
-        entity.mixins.first.to_s.should == mixin
+      context '#kind' do
+        it 'accepts kind from string' do
+          entity.kind = 'http://example.com/testnamespace#test'
+          expect(entity.kind).to eql Com::Example::Testnamespace::Test
+        end
+
+        it 'accepts kind from class' do
+          entity.kind = Com::Example::Testnamespace::Test
+          expect(entity.kind).to eql Com::Example::Testnamespace::Test
+        end
       end
 
-      # TODO: check adding of model
-      it "checks a valid attribute value against their definition in its kind and associated mixins" do
-        entity = Occi::Core::Entity.new
-        expect { entity.check }.to raise_error
-        entity.model = Occi::Model.new
-        entity.title = 'test'
-        uuid = UUIDTools::UUID.random_create.to_s
-        entity.id = uuid
-        expect { entity.check }.to_not raise_error
+      context '#mixins' do
+        let(:mixin){ 'http://example.com/mynamespace#mymixin' }   
+
+        it "converts mixin type identifiers to objects if a mixin is added to the entities mixins" do
+          entity.mixins << mixin
+          expect(entity.mixins.first.to_s).to eq mixin
+        end
+      end
+
+      context 'attributes' do
+
+        context 'checking attribute validity' do
+          before(:each) { Occi::Settings['compatibility']=false }
+          after(:each) { Occi::Settings.reload! }
+
+          it 'fails check with model missing' do
+            expect { entity.check }.to raise_error
+          end
+
+          it 'runs check successfully with a model registered' do
+            entity.model = Occi::Model.new
+            entity.title = 'test'
+            uuid = UUIDTools::UUID.random_create.to_s
+            Occi::Settings['verify_attribute_pattern']=true
+            expect { entity.id = uuid }.to_not raise_error
+          end
+
+          it 'rejects values not matching pattern' do
+            entity.model = Occi::Model.new
+            entity.id = 'id with spaces'
+            Occi::Settings['verify_attribute_pattern']=true
+            expect{ entity.id = 'id with spaces' }.to raise_error Occi::Errors::AttributeTypeError
+          end
+          
+        end
+        
+        context '#location' do
+          it 'can be set and read' do
+            entity.location = 'TestLoc'
+            expect(entity.location).to eq 'TestLoc'
+          end
+
+          it 'can be constructed from id' do
+            entity.id = UUIDTools::UUID.random_create.to_s
+            expect(entity.location).to eq '/entity/' + entity.id
+          end
+        end
+
+        context '#title' do
+          it 'can be set and read' do
+            entity.title = 'TestTitle'
+            expect(entity.title).to eq 'TestTitle'
+          end
+        end
+      end
+
+      context '#actions' do
+        it 'can be populated through redirection' do
+          entity.actions << testaction
+          expect(entity.actions.count).to eq 1
+        end
+
+        it 'can be assigned through the setter method' do
+          acts = Occi::Core::Actions.new
+          acts << testaction
+          entity.actions=acts
+          expect(entity.actions.count).to eq 1
+        end
+      end
+
+      context '#to_text' do
+        it 'renders fresh instance in text correctly' do
+          expected = %Q|Category: entity;scheme="http://schemas.ogf.org/occi/core#";class="kind"
+X-OCCI-Attribute: occi.core.id="baf1"|
+          expect(entity.to_text).to eq(expected)
+        end
+
+        it 'renders instance with attributes in text correctly' do
+          entity.actions << testaction
+          entity.title = 'TestTitle'
+          entity.location = '/TestLoc/1'
+          entity.mixins <<  'http://example.com/mynamespace#mymixin'
+
+          expected = %Q|Category: entity;scheme="http://schemas.ogf.org/occi/core#";class="kind"
+Category: mymixin;scheme="http://example.com/mynamespace#";class="mixin"
+X-OCCI-Attribute: occi.core.id="baf1"
+X-OCCI-Attribute: occi.core.title="TestTitle"
+Link: </TestLoc/1?action=testaction>;rel=http://schemas.ogf.org/occi/core/entity/action#testaction|
+          expect(entity.to_text).to eq(expected)
+        end
+      end
+
+      context '#to_header' do
+        it 'renders fresh instance in HTTP Header correctly' do
+          expected = Hashie::Mash.new
+          expected['Category'] = 'entity;scheme="http://schemas.ogf.org/occi/core#";class="kind"'
+          expected['X-OCCI-Attribute'] = 'occi.core.id="baf1"'
+
+          expect(entity.to_header).to eql(expected)
+        end
+
+        it 'renders instance with attributes in HTTP Header correctly' do
+          entity.actions << testaction
+          entity.title = 'TestTitle'
+          entity.location = '/TestLoc/1'
+          entity.mixins <<  'http://example.com/mynamespace#mymixin'
+
+          expected = Hashie::Mash.new
+          expected['Category'] = 'entity;scheme="http://schemas.ogf.org/occi/core#";class="kind",mymixin;scheme="http://example.com/mynamespace#";class="mixin"'
+          expected['X-OCCI-Attribute'] = 'occi.core.id="baf1",occi.core.title="TestTitle"'
+          expected['Link'] = '</TestLoc/1?action=testaction>;rel=http://schemas.ogf.org/occi/core/entity/action#testaction'
+
+          expect(entity.to_header).to eql(expected)
+        end
+      end
+
+      context '#check' do
+        let(:defs){
+          defs = Occi::Core::Attributes.new
+          defs['occi.core.id'] = { :type=> 'string',
+                                   :required => true }
+          defs['numbertype'] =   { :type => 'number',
+                                           :default => 42,
+                                           :mutable => true,
+                                           :pattern => '^[0-9]+'  }
+          defs['stringtype'] =   { :type => 'string',
+                                           :pattern => '[adefltuv]+',
+                                           :default => 'defaultvalue',
+                                           :mutable => true }
+          defs['booleantype'] =  { :type => 'boolean',
+                                           :default => true,
+                                           :mutable => true}
+          defs['booleantypefalse'] =  { :type => 'boolean',
+                                           :default => false,
+                                           :mutable => true }
+          defs['booleantypepattern'] =  { :type => 'boolean',
+                                           :default => true,
+                                           :mutable => true,
+                                           :pattern => true }
+          defs }
+        let(:kind){ Occi::Core::Kind.new 'http://schemas.ogf.org/occi/core#', 'testkind', 'Test Kind', defs }
+        let(:model){ model = Occi::Model.new
+          model.register(kind)
+          model.register(defmixin)
+          model }
+        let(:defmixin){ defmixin = Occi::Core::Mixin.new 'http://schemas.ogf.org/occi/core#', 'testmixin'
+          defmixin.attributes['mixinstring'] =  { :type => 'string',
+                                               :pattern => '.*',
+                                               :default => 'mixdefault',
+                                               :mutable => true }
+          defmixin }
+        let(:mixin){ Occi::Core::Mixin.new 'http://schemas.ogf.org/occi/core#', 'testmixin' }
+
+        let(:entity){ entity = Occi::Core::Entity.new(kind, [], defs)
+          entity.model = model
+          entity.mixins << mixin
+          entity }
+          
+        
+        before(:each){ Occi::Settings['compatibility']=false 
+                       Occi::Settings['verify_attribute_pattern']=true }
+        after(:each) { Occi::Settings.reload! }
+        context 'unsupported types' do
+          it 'refuses unsupported type' do
+            expect{ entity.attributes['othertype'] = { :type => 'other', :default => 'defaultvalue' } }.to raise_exception(Occi::Errors::AttributePropertyTypeError)
+          end
+        end
+        context 'defaults' do
+          context 'setting defaults' do
+            it 'sets numeric default' do
+              entity.check(true)
+              expect(entity.attributes['numbertype']).to eq 42
+            end
+            it 'sets string default' do
+              entity.check(true)
+              expect(entity.attributes['stringtype']).to eq 'defaultvalue'
+            end
+            it 'sets mixin string default' do
+              entity.check(true)
+              expect(entity.attributes['mixinstring']).to eq 'mixdefault'
+            end
+            it 'sets boolean default if true' do
+              entity.check(true)
+              expect(entity.attributes['booleantype']).to eq true
+            end
+            it 'sets boolean default if false' do
+              entity.check(true)
+              expect(entity.attributes['booleantypefalse']).to eq false
+            end
+            it 'can be checked twice in a row' do
+              entity.check(true)
+              expect{ entity.check(true) }.to_not raise_exception
+            end
+            it 'skips numeric default' do
+              entity.attributes['numbertype'] = 12
+              entity.check(true)
+              expect(entity.attributes['numbertype']).to eq 12
+            end
+            it 'skips string default' do
+              entity.attributes['stringtype'] = 'fault'
+              entity.check(true)
+              expect(entity.attributes['stringtype']).to eq 'fault'
+            end
+            it 'skips boolean default if true' do
+              entity.attributes['booleantype'] = false
+              entity.check(true)
+              expect(entity.attributes['booleantype']).to eq false
+            end
+            it 'skips boolean default if false' do
+              entity.attributes['booleantypefalse'] = true
+              entity.check(true)
+              expect(entity.attributes['booleantypefalse']).to eq true
+            end
+          end
+
+          context 'patterns' do
+            it 'checks string pattern' do
+              expect{ entity.attributes['stringtype'] = 'bflmpsvz' }.to raise_exception(Occi::Errors::AttributeTypeError)
+            end
+            it 'checks numeric pattern' do
+              expect{ entity.attributes['numbertype'] = -32 }.to raise_exception(Occi::Errors::AttributeTypeError)
+            end
+            it 'checks boolean pattern' do
+              expect{ entity.attributes['booleantypepattern'] = false }.to raise_exception(Occi::Errors::AttributeTypeError)
+            end
+          end
+        end
+
+        context 'exceptions' do
+          it 'raisees exception for missing model' do
+            ent = Occi::Core::Entity.new(kind, [], defs)
+            expect{ ent.check(true) }.to raise_exception ArgumentError
+          end
+
+          it 'raises exception for inexistent kind' do
+            ent = Occi::Core::Entity.new(kind, [], defs)
+            mod = Occi::Model.new
+            ent.model = mod
+            expect{ ent.check(true) }.to raise_exception Occi::Errors::KindNotDefinedError
+          end
+        end
+      end
+
+      context '#attribute_properties' do
+        it 'gets attribute properties' do
+          properties = entity.attribute_properties
+          expect(properties.occi.core.count).to eql 4
+        end
+      end
+
+      context '#empty?' do
+
+        it 'returns false for a new instance with defaults' do
+          expect(entity.empty?).to be_false
+        end
+
+        it 'returns true for an instance without a kind' do
+          ent = entity.clone
+          ent.kind = nil
+
+          expect(ent.empty?).to be_true
+        end
+
+        it 'returns true for an instance without an identifier' do
+          ent = entity.clone
+          ent.id = nil
+
+          expect(ent.empty?).to be_true
+        end
+
       end
 
     end