occi-core 4.3.6 → 5.0.0.alpha.1

data/spec/occi/core/category_spec.rb

@@ -1,216 +0,0 @@
-module Occi
-  module Core
-    describe Category 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('#') }
-
-      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 '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
-
-      context '#type_identifier' do
-
-        it 'returns the type identifier of the category' do
-          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
-
-      # rendering
-
-    end
-  end
-end

data/spec/occi/core/entities_spec.rb

@@ -1,160 +0,0 @@
-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":["http://schemas.ogf.org/occi/core/entity/action#testaction"],"attributes":{"occi":{"core":{"id":"e2testid"}}},"id":"e2testid"}')
-          expected << hash
-          expected << hash2
-          expect(entities.as_json).to eql expected
-        end
-
-      end
-
-      context '#check' do
-
-        let(:attr_w_defaults) do
-          { :type => 'string',
-            :pattern => '[adefltuv]+',
-            :default => 'defaultvalue',
-            :mutable => true }
-        end
-        let(:model) do
-          model = Occi::Model.new
-          model.kinds.first.attributes['string_attribute'] = attr_w_defaults
-          model
-        end
-        let(:entities_w_defaults) do
-          entities << Occi::Core::Entity.new
-          entities.model = model
-          entities
-        end
-        let(:entities_w_wrong_attrs) do
-          ent1 = Occi::Core::Entity.new
-          ent1.attributes['fake.attr.here'] = 1
-          entities << ent1
-          entities.model = model
-          entities
-        end
-
-        it 'raises an error on undeclared attributes' do
-          expect { entities_w_wrong_attrs.check }.to raise_error
-        end
-
-        it 'passes on an empty collection' do
-          expect { entities.check }.not_to raise_error
-          expect { entities.check(true) }.not_to raise_error
-        end
-
-        it 'does not set attribute defaults by default' do
-          entities_w_defaults.check
-          expect(entities_w_defaults.first.attributes['string_attribute']).to be_blank
-        end
-
-        it 'sets attributes default when requested' do
-          entities_w_defaults.check(true)
-          expect(entities_w_defaults.first.attributes['string_attribute']).to eq 'defaultvalue'
-        end
-
-      end
-    end
-  end
-end