occi-core 4.3.6 → 5.0.0.alpha.1

data/spec/occi/core/links_spec.rb

@@ -1,132 +0,0 @@
-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 Links with correctly initialized links' do
-            links = Occi::Core::Links.new ["/link/9c3b83bd-2456-45e9-8ce5-91a7d5c7bb85"]
-
-            expect(links.first.id).to eql "9c3b83bd-2456-45e9-8ce5-91a7d5c7bb85"
-            expect(links.first.location).to eql "/link/9c3b83bd-2456-45e9-8ce5-91a7d5c7bb85"
-          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/mixin_spec.rb

@@ -1,38 +0,0 @@
-module Occi
-  module Core
-    describe Mixin do
-
-      describe '#location' do
-        let(:mixin) { Occi::Core::Mixin.new }
-
-        it 'defaults to /mixin/term/' do
-          expect(mixin.location).to eq '/mixin/mixin/'
-        end
-
-        it 'gets normalized to a relative path' do
-          mixin.location = 'http://example.org/mixin/'
-          expect(mixin.location).to eq '/mixin/'
-        end
-
-        it 'can be set to nil' do
-          mixin.location = nil
-          expect(mixin.location).to be_nil
-        end
-
-        it 'raises an error when location does not start and end with a slash' do
-          expect { mixin.location = '/no_slash' }.to raise_error
-          expect { mixin.location = 'no_slash/' }.to raise_error
-        end
-
-        it 'raises an error when location contains spaces' do
-          expect { mixin.location = '/sla shes/' }.to raise_error
-        end
-
-        it 'can be set to an empty string' do
-          expect { mixin.location = '' }.not_to raise_error
-        end
-      end
-
-    end
-  end
-end

data/spec/occi/core/mixins_spec.rb

@@ -1,107 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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["default"] = "defaultvalue"
-            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["default"] = "defaultvalue"
-            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"] = true
-            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 = '{"default":"defaultvalue","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,42 +0,0 @@
-module Occi
-  module Core
-    describe Resource do
-      let(:resource){ resource = Occi::Core::Resource.new
-        resource.link 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.count).to eq 1
-        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 eq target.to_s
-        end
-
-        it 'sets the right source' do
-          expect(resource.links.first.source).to eq resource.to_s
-        end
-      end
-
-      context '#as_json' do
-        it 'renders to JSON with full links' do
-          expect(resource.as_json.links.first).to be_kind_of Hashie::Mash
-        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

@@ -1,12 +0,0 @@
-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