occi-core 4.1.3 → 4.2.0

data/spec/occi/infrastructure/compute_spec.rb

@@ -1,29 +1,229 @@
 module Occi
   module Infrastructure
     describe Compute do
+      let(:compute){ Occi::Infrastructure::Compute.new }
+      let(:modl){
+        modl = Occi::Model.new
+        modl.register_infrastructure
+        modl }
 
-      it "creates a storagelink to an existing storage resource" do
-        compute = Occi::Infrastructure::Compute.new
-        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
-        compute.storagelink target
-        compute.links.should have(1).link
-        compute.links.first.should be_kind_of Occi::Infrastructure::Storagelink
-        compute.links.first.target.should be target
+      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).to have(1).link
+          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 be target
+          end
+
+          it "has target with correct ID" do
+            compute.storagelink target
+            expect(compute.links.first.target.id).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.id).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).to have(1).link
+          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 be target
+          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.id).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
 
-      it "creates a networkinterface to an existing network resource" do
-        compute = Occi::Infrastructure::Compute.new
-        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
-        compute.networkinterface target
-        compute.links.should have(1).link
-        compute.links.first.should be_kind_of Occi::Infrastructure::Networkinterface
-        compute.links.first.target.should be target
+      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

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

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

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

@@ -0,0 +1,45 @@
+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,7 +1,101 @@
 module Occi
   describe Log do
 
-    it "logs a message to a pipe" 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
@@ -10,5 +104,14 @@ module Occi
       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