occi-core 4.3.6 → 5.0.0.alpha.1

data/spec/occi/infrastructure/compute_spec.rb

@@ -1,229 +0,0 @@
-module Occi
-  module Infrastructure
-    describe Compute do
-      let(:compute){ Occi::Infrastructure::Compute.new }
-      let(:modl){
-        modl = Occi::Model.new
-        modl.register_infrastructure
-        modl }
-
-      context 'Storage Links' do
-        let(:target){
-          target = Occi::Infrastructure::Storage.new
-          # create a random ID as the storage resource must already exist and therefore must have an ID assigned
-          target.id = UUIDTools::UUID.random_create.to_s 
-          target }
-
-        context '#storagelink' do
-          it "creates a single storagelink" do
-            compute.storagelink target
-            expect(compute.links.count).to eq 1
-          end
-
-          it "creates a storagelink to a storage resource" do
-            compute.storagelink target
-            expect(compute.links.first).to be_kind_of Occi::Infrastructure::Storagelink
-          end
-
-          it "has the correct link as target" do
-            compute.storagelink target
-            expect(compute.links.first.target).to eq target.to_s
-          end
-
-          it "has target with correct ID" do
-            compute.storagelink target
-            expect(compute.links.first.target.split('/').last).to eq target.id
-          end
-        end
-
-        context '#storagelinks' do
-          it 'has the correct number of members -- single' do
-            compute.storagelink target
-            compute.model=modl
-            expect(compute.storagelinks.count).to eq 1
-          end
-
-          it 'has the correct number of members -- double' do
-            target2 = Occi::Infrastructure::Storage.new
-            target2.id = UUIDTools::UUID.random_create.to_s 
-            compute.storagelink target
-            compute.storagelink target2
-            compute.model=modl
-            expect(compute.storagelinks.count).to eq 2
-          end
-
-          it 'shows correctly in collections' do
-            compute.storagelink target
-            compute.model=modl
-            expect(compute.storagelinks[0].target.split('/').last).to eq target.id
-          end
-        end
-      end
-
-      context 'Network Interfaces' do
-        let(:target){
-          target = Occi::Infrastructure::Network.new
-          # create a random ID as the network resource must already exist and therefore must have an ID assigned
-          target.id = UUIDTools::UUID.random_create.to_s
-          target }
-
-        context '#networkinterface' do
-          it "creates a single networkinterface" do
-            compute.networkinterface target
-            expect(compute.links.count).to eq 1
-          end
-
-          it "creates a networkinterface to a storage resource" do
-            compute.networkinterface target
-            expect(compute.links.first).to be_kind_of Occi::Infrastructure::Networkinterface
-          end
-
-          it "has the correct interface as target" do
-            compute.networkinterface target
-            expect(compute.links.first.target).to eq target.to_s
-          end
-        end
-
-        context '#networkinterfaces' do
-          it 'has the correct number of members -- single' do
-            compute.networkinterface target
-            compute.model=modl
-            expect(compute.networkinterfaces.count).to eq 1
-          end
-
-          it 'has the correct number of members -- double' do
-            target2 = Occi::Infrastructure::Network.new
-            target2.id = UUIDTools::UUID.random_create.to_s
-            compute.networkinterface target
-            compute.networkinterface target2
-            compute.model=modl
-            expect(compute.networkinterfaces.count).to eq 2
-          end
-
-          it 'shows correctly in collections' do
-            compute.networkinterface target
-            compute.model=modl
-            expect(compute.networkinterfaces[0].target.split('/').last).to eq target.id
-          end
-        end
-      end
-
-      context '#architecture' do
-        it 'can be set and read' do
-          compute.architecture = 'x64'
-          expect(compute.architecture).to eq 'x64'
-        end
-
-        context 'Pattern matching' do
-          before(:each) { Occi::Settings['compatibility']=false }
-          after(:each) { Occi::Settings.reload! }
-
-          it 'preserves non-matching values with verification settings off' do
-            Occi::Settings['verify_attribute_pattern']=false
-            compute.model=modl
-            expect{compute.architecture = 'z80'}.to_not raise_error
-          end
-
-          it 'rejects non-matching values with verification settings on' do
-            Occi::Settings['verify_attribute_pattern']=true
-            compute.model=modl
-            expect{compute.architecture = 'z80'}.to raise_error Occi::Errors::AttributeTypeError
-          end
-        end
-      end
-
-      context '#cores' do
-        it 'can be set and read' do
-          compute.cores = 32
-          expect(compute.cores).to eq 32
-        end
-
-        it 'rejects non-numeric values' do
-          expect{compute.memory = 'a few'}.to raise_error
-        end
-      end
-
-      context '#hostname' do
-        it 'can be set and read' do
-          compute.hostname = 'testhostname'
-          expect(compute.hostname).to eq 'testhostname'
-        end
-
-        context 'Pattern matching' do
-          before(:each) { Occi::Settings['compatibility']=false }
-          after(:each) { Occi::Settings.reload! }
-
-          it 'preserves non-matching values with verification settings off' do
-            Occi::Settings['verify_attribute_pattern']=false
-            compute.model=modl
-            expect{compute.hostname = 'notaproperhostname'}.to_not raise_error
-          end
-
-          it 'rejects non-matching values with verification settings on' do
-            Occi::Settings['verify_attribute_pattern']=true
-            compute.model=modl
-            expect{compute.hostname = 'notaproperhostname'}.to raise_error Occi::Errors::AttributeTypeError
-          end
-        end
-      end
-
-      context '#speed' do
-        it 'can be set and read' do
-          compute.speed = 3000.0
-          expect(compute.speed).to eq 3000.0
-        end
-
-        it 'rejects non-numeric values' do
-          expect{compute.memory = 'fast'}.to raise_error
-        end
-      end
-
-      context '#memory' do
-        it 'can be set and read' do
-          compute.memory = 4096
-          expect(compute.memory).to eq 4096
-        end
-
-        it 'rejects non-numeric values' do
-          expect{compute.memory = 'a lot'}.to raise_error
-        end
-      end
-
-      context '#state' do
-        it 'has correct default value with set_defaults == true' do
-          compute.model=modl
-          compute.check(true)
-          expect(compute.state).to eq 'inactive'
-        end
-
-        it 'does not take the default value with set_defaults set to default' do
-          compute.model=modl
-          compute.check
-          expect(compute.state).to_not eq 'inactive'
-        end
-
-        it 'can be set and read' do
-          compute.state = 'active'
-          expect(compute.state).to eq 'active'
-        end
-
-        context 'Pattern matching' do
-          before(:each) { Occi::Settings['compatibility']=false }
-          after(:each) { Occi::Settings.reload! }
-
-          it 'preserves non-matching values with verification settings off' do
-            Occi::Settings['verify_attribute_pattern']=false
-            compute.model=modl
-            expect{compute.state = 'broken'}.to_not raise_error
-          end
-
-          it 'rejects non-matching values with verification settings on' do
-            Occi::Settings['verify_attribute_pattern']=true
-            compute.model=modl
-            expect{compute.state = 'broken'}.to raise_error Occi::Errors::AttributeTypeError
-          end
-        end
-      end
-    end
-  end
-end

data/spec/occi/infrastructure/network_spec.rb

@@ -1,96 +0,0 @@
-module Occi
-  module Infrastructure
-    describe Network do
-
-      context 'setters/getters' do
-        let(:network){ Occi::Infrastructure::Network.new }
-        context '#vlan' do
-          it 'Can be set and read as attribute' do
-            network.vlan = 4
-            expect(network.attributes.occi.network.vlan).to eql 4
-          end
-
-          it 'Can be set and read through getter' do
-            network.vlan = 4
-            expect(network.vlan).to eql 4
-          end
-        end
-
-        context '#label' do
-          it 'Can be set and read as attribute' do
-            network.label = "Network Label"
-            expect(network.attributes.occi.network.label).to eql "Network Label"
-          end
-
-          it 'Can be set and read through getter' do
-            network.label = "Network Label"
-            expect(network.label).to eql "Network Label"
-          end
-        end
-
-        context '#state' do
-          it 'Can be set and read as attribute' do
-            network.state = "inactive"
-            expect(network.attributes.occi.network.state).to eql "inactive"
-          end
-
-          it 'Can be set and read through getter' do
-            network.state = "inactive"
-            expect(network.state).to eql "inactive"
-          end
-        end
-
-        context '#address' do
-          it 'Can be set and read as attribute' do
-            network.address = "127.0.0.1"
-            expect(network.attributes.occi.network.address).to eql "127.0.0.1"
-          end
-
-          it 'Can be set and read through getter' do
-            network.address = "127.0.0.1"
-            expect(network.address).to eql "127.0.0.1"
-          end
-        end
-
-        context '#gateway' do
-          it 'Can be set and read as attribute' do
-            network.gateway = "127.0.0.255"
-            expect(network.attributes.occi.network.gateway).to eql "127.0.0.255"
-          end
-
-          it 'Can be set and read through getter' do
-            network.gateway = "127.0.0.255"
-            expect(network.gateway).to eql "127.0.0.255"
-          end
-        end
-
-        context '#allocation' do
-          it 'Can be set and read as attribute' do
-            network.allocation = "static"
-            expect(network.attributes.occi.network.allocation).to eql "static"
-          end
-
-          it 'Can be set and read through getter' do
-            network.allocation = "static"
-            expect(network.allocation).to eql "static"
-          end
-        end
-      end
-
-      context '#ipnetwork' do
-        let(:network){ Occi::Infrastructure::Network.new }
-
-        it 'adds the Ipnetwork mixin' do
-          network.ipnetwork(true)
-          expect(network.mixins.first.to_s).to eql "http://schemas.ogf.org/occi/infrastructure/network#ipnetwork"
-        end
-
-        it 'removes the Ipnetwork mixin' do
-          network.ipnetwork(true)
-          network.ipnetwork(false)
-          expect(network.mixins.count).to eql 0
-        end
-      end
-    end
-  end
-end

data/spec/occi/infrastructure/networkinterface_spec.rb

@@ -1,96 +0,0 @@
-module Occi
-  module Infrastructure
-    describe Networkinterface do
-
-      context 'setters/getters' do
-        let(:networkinterface){ Occi::Infrastructure::Networkinterface.new }
-        context '#interface' do
-          it 'Can be set and read as attribute' do
-            networkinterface.interface = "eth0"
-            expect(networkinterface.attributes.occi.networkinterface.interface).to eql "eth0"
-          end
-
-          it 'Can be set and read through getter' do
-            networkinterface.interface = "eth0"
-            expect(networkinterface.interface).to eql "eth0"
-          end
-        end
-
-        context '#mac' do
-          it 'Can be set and read as attribute' do
-            networkinterface.mac = "FF-FF-FF-FF-FF-FF"
-            expect(networkinterface.attributes.occi.networkinterface.mac).to eql "FF-FF-FF-FF-FF-FF"
-          end
-
-          it 'Can be set and read through getter' do
-            networkinterface.mac = "FF-FF-FF-FF-FF-FF"
-            expect(networkinterface.mac).to eql "FF-FF-FF-FF-FF-FF"
-          end
-        end
-
-        context '#state' do
-          it 'Can be set and read as attribute' do
-            networkinterface.state = "error"
-            expect(networkinterface.attributes.occi.networkinterface.state).to eql "error"
-          end
-
-          it 'Can be set and read through getter' do
-            networkinterface.state = "error"
-            expect(networkinterface.state).to eql "error"
-          end
-        end
-
-        context '#address' do
-          it 'Can be set and read as attribute' do
-            networkinterface.address = "127.0.0.1"
-            expect(networkinterface.attributes.occi.networkinterface.address).to eql "127.0.0.1"
-          end
-
-          it 'Can be set and read through getter' do
-            networkinterface.address = "127.0.0.1"
-            expect(networkinterface.address).to eql "127.0.0.1"
-          end
-        end
-
-        context '#gateway' do
-          it 'Can be set and read as attribute' do
-            networkinterface.gateway = "127.0.0.255"
-            expect(networkinterface.attributes.occi.networkinterface.gateway).to eql "127.0.0.255"
-          end
-
-          it 'Can be set and read through getter' do
-            networkinterface.gateway = "127.0.0.255"
-            expect(networkinterface.gateway).to eql "127.0.0.255"
-          end
-        end
-
-        context '#allocation' do
-          it 'Can be set and read as attribute' do
-            networkinterface.allocation = "static"
-            expect(networkinterface.attributes.occi.networkinterface.allocation).to eql "static"
-          end
-
-          it 'Can be set and read through getter' do
-            networkinterface.allocation = "static"
-            expect(networkinterface.allocation).to eql "static"
-          end
-        end
-      end
-
-      context '#ipnetworkinterface' do
-        let(:networkinterface){ Occi::Infrastructure::Networkinterface.new }
-
-        it 'adds the Ipnetwork mixin' do
-          networkinterface.ipnetworkinterface(true)
-          expect(networkinterface.mixins.first.to_s).to eql "http://schemas.ogf.org/occi/infrastructure/networkinterface#ipnetworkinterface"
-        end
-
-        it 'removes the Ipnetwork mixin' do
-          networkinterface.ipnetworkinterface(true)
-          networkinterface.ipnetworkinterface(false)
-          expect(networkinterface.mixins.count).to eql 0
-        end
-      end
-    end
-  end
-end

data/spec/occi/infrastructure/storage_spec.rb

@@ -1,33 +0,0 @@
-module Occi
-  module Infrastructure
-    describe Storage do
-
-      context 'setters/getters' do
-        let(:storage){ Occi::Infrastructure::Storage.new }
-        context '#size' do
-          it 'Can be set and read as attribute' do
-            storage.size = 16777216
-            expect(storage.attributes.occi.storage['size']).to eql 16777216
-          end
-
-          it 'Can be set and read through getter' do
-            storage.size = 16777216
-            expect(storage.size).to eql 16777216
-          end
-        end
-
-        context '#state' do
-          it 'Can be set and read as attribute' do
-            storage.state = "online"
-            expect(storage.attributes.occi.storage.state).to eql "online"
-          end
-
-          it 'Can be set and read through getter' do
-            storage.state = "online"
-            expect(storage.state).to eql "online"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/occi/infrastructure/storagelink_spec.rb

@@ -1,45 +0,0 @@
-module Occi
-  module Infrastructure
-    describe Storagelink do
-
-      context 'setters/getters' do
-        let(:storagelink){ Occi::Infrastructure::Storagelink.new }
-        context '#deviceid' do
-          it 'Can be set and read as attribute' do
-            storagelink.deviceid = "sda"
-            expect(storagelink.attributes.occi.storagelink.deviceid).to eql "sda"
-          end
-
-          it 'Can be set and read through getter' do
-            storagelink.deviceid = "sda"
-            expect(storagelink.deviceid).to eql "sda"
-          end
-        end
-
-        context '#mountpoint' do
-          it 'Can be set and read as attribute' do
-            storagelink.mountpoint = "/mnt/sda"
-            expect(storagelink.attributes.occi.storagelink.mountpoint).to eql "/mnt/sda"
-          end
-
-          it 'Can be set and read through getter' do
-            storagelink.mountpoint = "/mnt/sda"
-            expect(storagelink.mountpoint).to eql "/mnt/sda"
-          end
-        end
-
-        context '#state' do
-          it 'Can be set and read as attribute' do
-            storagelink.state = "active"
-            expect(storagelink.attributes.occi.storagelink.state).to eql "active"
-          end
-
-          it 'Can be set and read through getter' do
-            storagelink.state = "active"
-            expect(storagelink.state).to eql "active"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/occi/log_spec.rb

@@ -1,117 +0,0 @@
-module Occi
-  describe Log do
-
-    context 'logging to files' do
-      let!(:testIO){ StringIO.new}
-      let!(:logger){ Occi::Log.new(testIO) }
-      after(:each) do
-        logger.close
-      end
-
-      it 'logs correctly with prioritiy DEBUG' do
-        Occi::Log.debug("Test Debug Text")
-        expect(testIO.string).to match (/D.*DEBUG.*Test Debug Text/)
-      end
-
-      it 'logs correctly with prioritiy INFO' do
-        Occi::Log.info("Test Info Text")
-        expect(testIO.string).to match (/I.*INFO.*Test Info Text/)
-      end
-
-      it 'logs correctly with prioritiy WARN' do
-        Occi::Log.warn("Test Warning Text")
-        expect(testIO.string).to match (/W.*WARN.*Test Warning Text/)
-      end
-
-      it 'logs correctly with prioritiy ERROR' do
-        Occi::Log.error("Test Error Text")
-        expect(testIO.string).to match (/E.*ERROR.*Test Error Text/)
-      end
-
-      it 'logs correctly with prioritiy FATAL' do
-        Occi::Log.fatal("Test Fatal Text")
-        expect(testIO.string).to match (/F.*FATAL.*Test Fatal Text/)
-      end
-
-      context "with log level set to filter out some messages" do
-        before(:each) do
-          logger.level=Occi::Log::ERROR
-        end
-        it 'does not log prioritiy DEBUG with log level set to ERROR' do
-          Occi::Log.debug("Second Debug Text")
-          expect(testIO.string).to_not match (/D.*DEBUG.*Second Debug Text/)
-        end
-
-        it 'does not log prioritiy WARN with log level set to ERROR' do
-          Occi::Log.info("Second Info Text")
-          expect(testIO.string).to_not match (/I.*INFO.*Second Info Text/)
-        end
-
-        it 'does not log prioritiy WARN with log level set to ERROR' do
-          Occi::Log.warn("Second Warning Text")
-          expect(testIO.string).to_not match (/W.*WARN.*Second Warning Text/)
-        end
-
-        it 'still logs with prioritiy ERROR' do
-          Occi::Log.error("Second Error Text")
-          expect(testIO.string).to match (/E.*ERROR.*Second Error Text/)
-        end
-
-        it 'still logs with prioritiy FATAL' do
-          Occi::Log.fatal("Second Fatal Text")
-          expect(testIO.string).to match (/F.*FATAL.*Second Fatal Text/)
-        end
-      end
-
-      it 'tells log lines apart correctly' do #This tests the correctness of the testing procedure rather than the code itself
-        Occi::Log.error("Second Error Text")
-        Occi::Log.fatal("Second Fatal Text")
-        expect(testIO.string).to_not match (/E.*ERROR.*Test Fatal Text/)
-      end
-
-    end
-
-    it 'copes with read-only log file' do
-      (contents = "locked file contents").freeze
-      testIO = StringIO.open(contents)
-      logger = Occi::Log.new(testIO)
-      expect(Occi::Log.fatal("New content")).to eq nil
-      logger.close
-    end
-
-    context 'reporting current log levels correctly' do
-      testIO = StringIO.new
-      logger = Occi::Log.new(testIO)
-
-      it 'has initial log level set to 0' do
-        expect(logger.level).to eq 0
-      end
-
-      it 'reports ERROR log level correctly' do
-        logger.level=Occi::Log::ERROR
-        expect(logger.level).to eq 3
-      end
-
-      logger.close
-    end
-
-    it 'logs through a pipe' do
-      r, w = IO.pipe
-      logger = Occi::Log.new(w)
-      logger.level = Occi::Log::INFO
-      Occi::Log.info("Test")
-      r.readline.include?("Test")
-      logger.close
-    end
-
-    it 'logs through a pre-initiated Logger' do
-      r, w = IO.pipe
-      logger = Occi::Log.new(Logger.new(w))
-      logger.level = Occi::Log::INFO
-      Occi::Log.info("Test")
-      r.readline.include?("Test")
-      logger.close
-    end
-
-  end
-end