occi-core 4.1.3 → 4.2.0

data/spec/occi/core/kind_spec.rb

@@ -4,21 +4,33 @@ module Occi
 
       describe '#get_class' do
 
-        it 'gets OCCI Resource class by term and scheme' do
-          scheme = 'http://schemas.ogf.org/occi/core'
-          term = 'resource'
-          klass = Occi::Core::Kind.get_class scheme, term
-          klass.should be Occi::Core::Resource
-          klass.superclass.should be Occi::Core::Entity
+        context 'OCCI Resource class' do
+          let(:scheme){ 'http://schemas.ogf.org/occi/core' }
+          let(:term){ 'resource' }
+          let(:klass){ Occi::Core::Kind.get_class scheme, term }
+
+          it 'gets OCCI Resource class by term term and scheme' do
+            expect(klass).to be Occi::Core::Resource
+          end
+          it 'also gets the superclass' do
+            expect(klass.superclass).to be Occi::Core::Entity
+            #TODO: Possibly move this test to resource_spec?
+          end
         end
 
-        it 'gets non predefined OCCI class by term, scheme and related class' do
-          scheme = 'http://example.com/occi'
-          term = 'test'
-          related = ['http://schemas.ogf.org/occi/core#resource']
-          klass = Occi::Core::Kind.get_class scheme, term, related
-          klass.should be Com::Example::Occi::Test
-          klass.superclass.should be Occi::Core::Resource
+        context 'non-predefined OCCI class' do
+          let(:scheme){ 'http://example.com/occi' }
+          let(:term){ 'test' }
+          let(:related){ ['http://schemas.ogf.org/occi/core#resource'] }
+          let(:klass){ Occi::Core::Kind.get_class scheme, term, related }
+
+          it 'gets non predefined OCCI class by term, scheme and related class' do
+            expect(klass).to be Com::Example::Occi::Test
+          end
+          it 'also gets the superclass' do
+            expect(klass.superclass).to be Occi::Core::Resource
+            #TODO: Possibly move this test to resource_spec?
+          end
         end
 
         it 'does not get OCCI class by term and scheme if it relates to existing class not derived from OCCI Entity' do
@@ -28,17 +40,116 @@ module Occi
           expect { Occi::Core::Kind.get_class scheme, term, related }.to raise_error
         end
 
+        context 'in case of improper input' do
+
+          it 'handles parent overriden with nil' do
+            expect(Occi::Core::Kind.get_class 'http://schemas.ogf.org/occi/core', 'resource', nil).to eq Occi::Core::Resource
+          end
+          
+          it 'copes with invalid characters in scheme' do
+            expect{Occi::Core::Kind.get_class 'http://schemas ogf.org/occi/core', 'resource'}.to raise_error(URI::InvalidURIError)
+          end
+          it 'copes with non-URI-like structure of the scheme' do
+            expect{Occi::Core::Kind.get_class 'doesnotexist', 'resource'}.to raise_error(StandardError)
+          end
+
+          context 'handling invalid characters in term' do
+            after { Occi::Settings.reload! }
+            it 'copes with compatibility on' do
+              Occi::Settings['compatibility'] = true
+              expect(Occi::Core::Kind.get_class 'http://schemas.ogf.org/occi/core', '# #resource$').to eq Occi::Core::Resource
+            end
+            
+            it 'copes with compatibility off' do
+              Occi::Settings['compatibility'] = false
+              expect{Occi::Core::Kind.get_class 'http://schemas.ogf.org/occi/core', '# #resource$'}.to raise_error(ArgumentError)
+            end
+          end
+          
+          it 'handles nil scheme' do
+            expect{Occi::Core::Kind.get_class nil, 'resource'}.to raise_error(ArgumentError)
+          end
+
+          it 'handles nil resource' do
+            expect{Occi::Core::Kind.get_class 'http://schemas.ogf.org/occi/core', nil}.to raise_error(ArgumentError)
+          end
+
+          it 'copes with invalid parent' do
+            expect{Occi::Core::Kind.get_class 'http://example.com/occi', 'test', 'http://s  chemas.ogf.org/occi/core#resource'}.to raise_error(URI::InvalidURIError)
+          end
+
+          it 'copes with parent missing term' do
+            expect{Occi::Core::Kind.get_class 'http://example.com/occi', 'test', 'http://s  chemas.ogf.org/occi/core'}.to raise_error(ArgumentError)
+          end
+
+        end
+
       end
 
       describe '#related_to?' do
+        let(:base){ Occi::Core::Kind.new 'http://occi.test.case/core/kind', 'base' }
+        let(:related){ Occi::Core::Kind.new 'http://occi.test.case/core/kind/base', 'related', 'title', Occi::Core::Attributes.new, base }
+        let(:unrelated){ Occi::Core::Kind.new 'http://occi.test.case/core/kind', 'unrelated' }
+
+        it 'recognizes existing relationship' do
+          expect(related.related_to?(base)).to eq true
+        end
+
+        it 'does not give false positives on non-existent relationship' do
+          expect(base.related_to?(unrelated)).to eq false
+        end
 
-        it 'checks if the kind is related to another kind' do
-          kind = Occi::Core::Resource.kind
-          kind.related_to?(Occi::Core::Entity.kind).should be true
+        it 'recognizes transitive relationships' #do #TODO This test actually works, but fails because te feature is not yet implemented
+#          grandchild = Occi::Core::Kind.new 'http://occi.test.case/core/kind/base', 'related', 'title', Occi::Core::Attributes.new, related
+#          expect(grandchild.related_to?(base)).to eq true
+#        end
+      end
+
+      describe '#as_json' do
+        let(:kind){ Occi::Core::Kind.new }
+
+        it 'renders JSON correctly from freshly initialized object' do
+          expected = '{"location":"/kind/","term":"kind","scheme":"http://schemas.ogf.org/occi/core#","attributes":{}}'
+          hash=Hashie::Mash.new(JSON.parse(expected))
+          expect(kind.as_json).to eql(hash)
+        end
+
+        it 'renders JSON correctly with optional attributes' do
+          kind.title = "test title"
+          expected = '{"location":"/kind/","term":"kind","scheme":"http://schemas.ogf.org/occi/core#","title":"test title","attributes":{}}'
+          hash=Hashie::Mash.new(JSON.parse(expected))
+          expect(kind.as_json).to eql(hash)
+        end
+
+        it 'renders JSON correctly with special characters' do
+          kind.title = "Some special characters @#\$%"
+          expected = '{"location":"/kind/","term":"kind","scheme":"http://schemas.ogf.org/occi/core#","title":"Some special characters @#\$%","attributes":{}}'
+          hash=Hashie::Mash.new(JSON.parse(expected))
+          expect(kind.as_json).to eql(hash)
         end
 
       end
 
+      describe '#to_string' do
+        let(:kind){ Occi::Core::Kind.new }
+
+        it 'produces a string correctly from freshly initialized object' do
+          expected = ('scheme="http://schemas.ogf.org/occi/core#";class="kind";location="/kind/";kind').split(/;/)
+          actual = kind.to_string.split(/;/)
+          expect(actual).to match_array(expected)
+        end
+
+        it 'produces a string correctly with optional attributes' do
+          kind.title = "test title"
+          expected = ('scheme="http://schemas.ogf.org/occi/core#";class="kind";location="/kind/";kind;title="test title"').split(/;/)
+          actual = kind.to_string.split(/;/)
+          expect(actual).to match_array(expected)
+        end
+
+#        TODO: Optional attributes, special characters
+
+      end
+
     end
   end
 end

data/spec/occi/core/link_spec.rb

@@ -0,0 +1,35 @@
+module Occi
+  module Core
+    describe Link do
+      # XXX This is a poor man's spec file, by no means exhaustive
+      # XXX So far it is only used to cover code otherwise not
+      # XXX covered by calls from other specs
+
+      context '#check' do
+        let(:defs){
+          defs = Occi::Core::Attributes.new
+          defs['occi.core.id'] = { :type=> 'string', :required => true }
+          defs['stringtype'] =   { :type => 'string', :pattern => '[adefltuv]+',
+                                           :default => 'defaultforlink', :mutable => true, :required => true }
+          defs }
+
+        it 'sets default for required attribute' do
+          link = Occi::Core::Link.new
+          link.kind.attributes.merge!(defs)
+          model = Occi::Model.new
+          model.register(link.kind)
+          link.model = model
+
+          link.check
+          expect(link.attributes['stringtype']).to eql 'defaultforlink'
+        end
+
+        it 'raises error if no relationship is set' do
+          norel = Occi::Core::Link.new
+          norel.instance_eval { @rel=nil }
+          expect{ norel.check }.to raise_exception ArgumentError
+        end
+      end 
+    end
+  end
+end

data/spec/occi/core/links_spec.rb

@@ -0,0 +1,130 @@
+module Occi
+  module Core
+    describe Links do
+
+      context '.initialize' do
+        it 'initializes an empty Links set' do
+          links = Occi::Core::Links.new
+          expect(links).to eql []
+        end
+
+        context 'with multiple members' do
+          let(:link1){ Occi::Core::Link.new }
+          let(:link2){ Occi::Core::Link.new }
+          let(:links){ Occi::Core::Links.new [link1,link2] }
+          let(:expected){ expected = []
+            links.each { |ln| expected << ln.id }
+            expected }
+
+          it 'produces the right number of members' do
+            expect(links.count).to eql 2
+          end
+
+          it 'has the first link' do
+            expect(link1.id).to satisfy { |id| expected.include?(id) }
+          end
+
+          it 'has the second link' do
+            expect(link2.id).to satisfy { |id| expected.include?(id) }
+          end
+        end
+
+        context 'with strings' do
+          it 'produces the right number of members, strings only' do
+            links = Occi::Core::Links.new ["target1","target2"]
+            expect(links.count).to eql 2
+          end
+
+          it 'populates target in the link' do
+            links = Occi::Core::Links.new ["target1"]
+            expect(links.first.target).to eql "target1"
+          end
+
+          it 'produces the right number of members, string/link combination' do
+            link2 = Occi::Core::Link.new
+            links = Occi::Core::Links.new ["target1",link2]
+            expect(links.count).to eql 2
+          end
+        end
+
+
+      end
+
+      context '<<' do
+        context 'into an empty set' do
+          let(:link1){ Occi::Core::Link.new }
+          let(:links){ links = Occi::Core::Links.new
+            links << link1
+            links }
+
+          it 'produces the right number of members' do
+            expect(links.count).to eql 1
+          end
+
+          it 'has the link' do
+            expect(links.first.id).to eql link1.id
+          end
+        end
+
+        context 'into a populated set' do
+          let(:link1){ Occi::Core::Link.new }
+          let(:link2){ Occi::Core::Link.new }
+          let(:links){ links = Occi::Core::Links.new [link2]
+            links << link1
+            links }
+          let(:expected){ expected = []
+            links.each { |ln| expected << ln.id }
+            expected }
+
+          it 'produces the right number of members' do
+            expect(links.count).to eql 2
+          end
+
+          it 'has the first link' do
+            expect(link1.id).to satisfy { |id| expected.include?(id) }
+          end
+
+          it 'has the second link' do
+            expect(link2.id).to satisfy { |id| expected.include?(id) }
+          end
+        end
+      end
+
+      context '.create' do
+        context 'in an empty set' do
+          let!(:links){ Occi::Core::Links.new }
+          let!(:link1){ links.create }
+
+          it 'produces the right number of members' do
+            expect(links.count).to eql 1
+          end
+
+          it 'has the link' do
+            expect(links.first.id).to eql link1.id
+          end
+        end
+
+        context 'in a populated set' do
+          let(:link2){ Occi::Core::Link.new }
+          let!(:links){ Occi::Core::Links.new [link2] }
+          let!(:link1){ links.create }
+          let!(:expected){ expected = []
+            links.each { |ln| expected << ln.id }
+            expected }
+
+          it 'produces the right number of members' do
+            expect(links.count).to eql 2
+          end
+
+          it 'has the first link' do
+            expect(link1.id).to satisfy { |id| expected.include?(id) }
+          end
+
+          it 'has the second link' do
+            expect(link2.id).to satisfy { |id| expected.include?(id) }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/occi/core/mixins_spec.rb

@@ -0,0 +1,107 @@
+module Occi
+  module Core
+    describe Mixins do
+
+      context '#entity=' do
+        let(:ent){ Occi::Core::Entity.new }
+        let(:mixins){ Occi::Core::Mixins.new }
+
+        context 'assignment with mixins set empty' do
+          let(:mixin){ Occi::Core::Mixin.new }
+          it 'assigns entity to an empty mixin' do
+            mixins.entity = ent
+            expect(mixins.entity).to eql ent
+          end
+        end
+
+        context 'converting attributes form members into the assigned entity' do
+          let(:mixin){ mixin = Occi::Core::Mixin.new 
+            mixin.attributes['stringtype'] = { :type => 'string',
+                                               :pattern => '[adefltuv]+',
+                                               :default => 'defaultvalue',
+                                               :mutable => true }
+            mixin.attributes['stringtype'] = 'flute' 
+            mixin }
+
+          before(:each) {
+            mixins << mixin
+            mixins.entity = ent }
+
+          it 'removes assigned values' do
+            expect(mixins.entity.attributes['stringtype']).to eql nil
+          end
+
+          it 'preserves attribute properties' do
+            expect(mixins.entity.attributes['_stringtype']).to_not eql nil
+          end
+        end
+      end
+
+      context '<<' do
+        let!(:mixins){ Occi::Core::Mixins.new }
+
+        it 'adds a mixin to an empty set' do
+          mixins << Occi::Infrastructure::OsTpl.mixin
+          expect(mixins.include?(Occi::Infrastructure::OsTpl.mixin)).to eql true
+        end
+
+        it 'adds a mixin to an empty set' do
+          mixins << Occi::Infrastructure::OsTpl.mixin
+          mixins << Occi::Infrastructure::ResourceTpl.mixin
+          expect(mixins.include?(Occi::Infrastructure::ResourceTpl.mixin)).to eql true
+        end
+
+        it 'only adds the supplied mixin' do
+          mixins << Occi::Infrastructure::OsTpl.mixin
+          expect(mixins.include?(Occi::Infrastructure::ResourceTpl.mixin)).to eql false
+        end
+
+        it 'adds mixin from string' do
+          mixins << "http://schemas.ogf.org/occi/core#testmixin"
+          expect(mixins.first.term).to eql "testmixin"
+        end
+      end
+
+      context '#remove' do
+        let!(:mixins){ Occi::Core::Mixins.new }
+
+        it 'removes last mixin from the set' do
+          mixins << Occi::Infrastructure::OsTpl.mixin
+          mixins.remove(Occi::Infrastructure::OsTpl.mixin)
+          expect(mixins.include?(Occi::Infrastructure::OsTpl.mixin)).to eql false
+        end
+
+        it 'removes mixin from among multiple members' do
+          mixins << Occi::Infrastructure::OsTpl.mixin
+          mixins << Occi::Infrastructure::ResourceTpl.mixin
+          mixins.remove(Occi::Infrastructure::OsTpl.mixin)
+          expect(mixins.include?(Occi::Infrastructure::OsTpl.mixin)).to eql false
+        end
+
+        it 'leaves other unaffected' do
+          mixins << Occi::Infrastructure::OsTpl.mixin
+          mixins << Occi::Infrastructure::ResourceTpl.mixin
+          mixins.remove(Occi::Infrastructure::OsTpl.mixin)
+          expect(mixins.include?(Occi::Infrastructure::ResourceTpl.mixin)).to eql true
+        end
+
+        it 'removes attributes from the entity attribute' do
+          ent = Occi::Core::Entity.new
+          mixin = Occi::Core::Mixin.new
+          mixin.attributes['stringtype'] = { :type => 'string', :pattern => '[adefltuv]+', :default => 'defaultvalue', :mutable => true }
+          mixin.attributes['stringtype'] = 'flute'
+
+          mixins << mixin
+          mixins.entity = ent
+
+          mixins.remove(mixin)
+
+          expect(mixins.entity.attributes['_stringtype']).to eql nil
+        end
+      end
+
+      context '#convert' do
+      end
+    end
+  end
+end

data/spec/occi/core/properties_spec.rb

@@ -0,0 +1,167 @@
+module Occi
+  module Core
+    describe Properties do
+
+      context '#type=' do
+        let(:properties){ Occi::Core::Properties.new }
+        it 'accepts string' do
+          expect{ properties.type = 'string' }.to_not raise_exception
+        end
+
+        it 'accepts number' do
+          expect{ properties.type = 'number' }.to_not raise_exception
+        end
+
+        it 'accepts boolean' do
+          expect{ properties.type = 'boolean' }.to_not raise_exception
+        end
+
+        it 'rejects another string' do
+          expect{ properties.type = 'other' }.to raise_exception Occi::Errors::AttributePropertyTypeError
+        end
+
+      end
+
+      context '#check_value_for_type' do
+        context 'string' do
+          let(:properties){ properties = Occi::Core::Properties.new
+            properties.type = 'string'
+            properties }
+
+          it 'permits string' do
+            expect{ properties.check_value_for_type("string") }.to_not raise_exception
+          end
+
+          it 'rejects nil' do
+            expect{ properties.check_value_for_type(nil) }.to raise_exception(Occi::Errors::AttributeTypeError)
+          end
+
+          it 'rejects another class' do
+            expect{ properties.check_value_for_type(true) }.to raise_exception(Occi::Errors::AttributeTypeError)
+          end
+        end
+
+        context 'number' do
+          let(:properties){ properties = Occi::Core::Properties.new
+            properties.type = 'number' 
+            properties }
+
+          it 'permits number' do
+            expect{ properties.check_value_for_type(42) }.to_not raise_exception
+          end
+
+          it 'rejects nil' do
+            expect{ properties.check_value_for_type(nil) }.to raise_exception(Occi::Errors::AttributeTypeError)
+          end
+
+          it 'rejects another class' do
+            expect{ properties.check_value_for_type("string") }.to raise_exception(Occi::Errors::AttributeTypeError)
+          end
+        end
+
+        context 'boolean' do
+          let(:properties){ properties = Occi::Core::Properties.new
+            properties.type = 'boolean'
+            properties }
+
+          it 'permits true' do
+            expect{ properties.check_value_for_type(true) }.to_not raise_exception
+          end
+
+          it 'permits false' do
+            expect{ properties.check_value_for_type(false) }.to_not raise_exception
+          end
+
+          it 'rejects nil' do
+            expect{ properties.check_value_for_type(nil) }.to raise_exception(Occi::Errors::AttributeTypeError)
+          end
+
+          it 'rejects another class' do
+            expect{ properties.check_value_for_type(0) }.to raise_exception(Occi::Errors::AttributeTypeError)
+          end
+        end
+      end
+
+      context 'rendering' do
+        let(:properties) { properties = Occi::Core::Properties.new
+          properties.type = "string"
+          properties.required = true
+          properties.mutable = true
+          properties.default = "defaultvalue"
+          properties.description = "Required string value"
+          properties.pattern = "[adefltuv]+"
+          properties }
+
+        context '#to_hash' do
+          it 'makes a correct rendering' do
+            expected = Hash.new
+            expected["description"] = "Required string value"
+            expected["mutable"] = true
+            expected["pattern"] = "[adefltuv]+"
+            expected["required"] = true
+            expected["type"] = "string"
+
+            expect(properties.to_hash).to eql expected
+          end
+        end
+
+        context '#as_json' do
+          it 'makes a correct rendering' do
+            expected = Hash.new
+            expected["description"] = "Required string value"
+            expected["mutable"] = true
+            expected["pattern"] = "[adefltuv]+"
+            expected["required"] = true
+            expected["type"] = "string"
+    
+            expect(properties.to_hash).to eql expected
+          end
+
+          it 'makes a correct rendering of empty props' do
+            empty = Occi::Core::Properties.new
+            expected = Hash.new
+            expected["mutable"] = false
+            expected["pattern"] = ".*"
+            expected["required"] = false
+            expected["type"] = "string"
+      
+            expect(empty.to_hash).to eql expected
+          end 
+
+        end
+
+        context '#to_json' do
+          it 'makes a correct rendering' do
+            expected = '{"type":"string","required":true,"mutable":true,"pattern":"[adefltuv]+","description":"Required string value"}'
+            expect(properties.to_json).to eql expected
+          end
+        end
+      end
+
+      context '#empty?' do
+        let(:properties) { properties = Occi::Core::Properties.new
+          properties.type = "string"
+          properties.required = true
+          properties.mutable = true
+          properties.default = "defaultvalue"
+          properties.description = "Required string value"
+          properties.pattern = "[adefltuv]+"
+          properties }
+
+        it 'Returns false for non-empty props' do
+          expect(properties.empty?).to be false
+        end
+
+        it 'Returns true for empty props' do
+          empty = Occi::Core::Properties.new
+          empty.mutable = nil
+          empty.pattern = nil
+          empty.required = nil
+          empty.instance_eval { @type=nil }
+
+          expect(empty.empty?).to be true
+        end
+      end
+    end
+  end
+end

data/spec/occi/core/resource_spec.rb

@@ -1,18 +1,32 @@
 module Occi
   module Core
     describe Resource do
-
-      it "links another resource succesfully" do
-        resource = Occi::Core::Resource.new
-        target = Occi::Core::Resource.new
-        # create a random ID as the resource must already exist and therefore must have an ID assigned
-        target.id = UUIDTools::UUID.random_create.to_s
+      let(:resource){ resource = Occi::Core::Resource.new 
         resource.link target
-        resource.links.should have(1).link
-        resource.links.first.should be_kind_of Occi::Core::Link
-        resource.links.first.target.should be target
+        resource.attributes.occi!.core!.summary = "Resource Summary"
+        resource }
+      let(:target){ target = Occi::Core::Resource.new }
+      
+      context '#link' do
+        it "creates the appropriate No. of links" do
+          expect(resource.links).to have(1).link
+        end
+
+        it "has the correct kind" do
+          expect(resource.links.first).to be_kind_of Occi::Core::Link
+        end
+
+        it 'sets the right target' do
+          expect(resource.links.first.target).to eql target
+        end
       end
 
+      context '#summary' do
+        it 'gets the summary attribute corectly' do
+          expected = "Resource Summary"
+          expect(resource.summary).to eql expected
+        end
+      end
     end
   end
 end

data/spec/occi/core_spec.rb

@@ -0,0 +1,12 @@
+module Occi
+  describe Core do
+
+    context ".kinds" do
+      it 'initializes kinds' do
+        kinds = Occi::Core.kinds
+        expected = Occi::Core::Kinds.new << Occi::Core::Entity.kind << Occi::Core::Link.kind << Occi::Core::Resource.kind
+        expect(kinds).to eql expected
+      end
+    end
+  end
+end