lorj 1.0.9 → 1.0.10

data/spec/04_prc_core_config_spec.rb

@@ -1,325 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-#  require 'byebug'
-
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'rh.rb'
-require 'prc.rb'
-require 'prc_base_config.rb'
-require 'prc_core_config.rb'
-
-describe 'class: PRC::CoreConfig,' do
-  context 'when creating a new instance' do
-    before(:all) do
-      @config = PRC::CoreConfig.new
-    end
-
-    it 'should be loaded' do
-      expect(@config).to be
-    end
-
-    it 'runtime set works' do
-      expect(@config[:test] = :toto).to eq(:toto)
-      expect(@config.exist?(:test)).to eq(true)
-      expect(@config[:test]).to eq(:toto)
-    end
-  end
-
-  context 'from a child class, with local layer set to :test => :found_local, '\
-          ':test2 => {:test => :subhash} and runtime layer' do
-    before(:all) do
-      # Child class definition for rSpec.
-      class Test1 < PRC::CoreConfig
-        def initialize
-          local = PRC::BaseConfig.new(:test => :found_local,
-                                      :test2 => { :test => :subhash })
-          layers = []
-          layers << PRC::CoreConfig.define_layer(:name => 'local',
-                                                 :config => local)
-          layers << PRC::CoreConfig.define_layer # runtime
-
-          initialize_layers(layers)
-        end
-
-        def iexist?(options)
-          p_exist?(options)
-        end
-
-        def set(options)
-          p_set(options)
-        end
-
-        def get(options)
-          p_get(options)
-        end
-      end
-      @config = Test1.new
-    end
-
-    it 'should be loaded' do
-      expect(@config).to be
-      expect(@config.layers).to eq(%w(runtime local))
-    end
-
-    it 'config.version("local") return nil' do
-      expect(@config.version('local')).to equal(nil)
-    end
-
-    it 'config.version("runtime") return nil' do
-      expect(@config.version('runtime')).to equal(nil)
-    end
-
-    it 'config.version["inexistent"] return nil' do
-      expect(@config.version('inexistent')).to equal(nil)
-    end
-
-    it 'only config.version_set("local") = "1"' do
-      expect(@config.version_set('local', '1')).to eq('1')
-    end
-
-    it 'only config.version("local") return "1"' do
-      expect(@config.version('local')).to eq('1')
-      expect(@config.version('runtime')).to equal(nil)
-      expect(@config.version('inexistent')).to equal(nil)
-    end
-
-    it 'config.exist?(:test) returns true' do
-      expect(@config.exist?(:test)).to equal(true)
-    end
-
-    it 'config.p_exist?(:keys => [:test]) returns true' do
-      expect(@config.iexist?(:keys => [:test])).to equal(true)
-    end
-
-    it 'config.p_exist?(:keys => [:test], :name => "runtime") returns false' do
-      expect(@config.iexist?(:keys => [:test],
-                             :name => 'runtime')).to equal(false)
-    end
-
-    it 'config.p_exist?(:keys => [:test], :names => ["runtime"])'\
-       ' returns false' do
-      expect(@config.iexist?(:keys => [:test],
-                             :names => ['runtime'])).to equal(false)
-    end
-
-    it 'config.p_exist?(:keys => [:test], :names => ["local"]) returns true' do
-      expect(@config.iexist?(:keys => [:test],
-                             :names => ['local'])).to equal(true)
-    end
-
-    it 'config.exist?(:test2, :test) returns true' do
-      expect(@config.exist?(:test2, :test)).to equal(true)
-    end
-
-    it 'config.where?(:test) should be ["local"]' do
-      expect(@config.where?(:test)).to eq(['local'])
-    end
-
-    it 'config.where?(:test2) should be ["local"]' do
-      expect(@config.where?(:test2)).to eq(['local'])
-    end
-
-    it 'config.where?(:test2, :test) should be ["local"]' do
-      expect(@config.where?(:test2, :test)).to eq(['local'])
-    end
-
-    it 'config.[:test] = :where set in "runtime".' do
-      expect(@config[:test] = :where).to eq(:where)
-      expect(@config.where?(:test)).to eq(%w(runtime local))
-      expect(@config[:test]).to equal(:where)
-    end
-
-    it 'config.del(:test) remove the data from runtime, '\
-       'and restore from local.' do
-      expect(@config.del(:test)).to eq(:where)
-      expect(@config[:test]).to equal(:found_local)
-    end
-
-    it 'PRC::CoreConfig.define_layer(...) return a valid standalone layer' do
-      config = PRC::BaseConfig.new
-      layer = PRC::CoreConfig.define_layer(:name => 'instant',
-                                           :config => config)
-      expect(layer).to be
-      expect(layer[:name]).to eq('instant')
-      expect(layer[:config]).to eq(config)
-      expect(layer[:set]).to equal(true)
-      expect(layer[:load]).to equal(false)
-      expect(layer[:save]).to equal(false)
-      expect(layer[:file_set]).to equal(false)
-    end
-
-    it "config.layer_add(:name => 'instant') return true if layer is added" do
-      layer = PRC::CoreConfig.define_layer(:name => 'instant')
-      expect(@config.layer_add layer).to equal(true)
-    end
-
-    it 'config.layers return %w(instant runtime local)' do
-      expect(@config.layers).to eq(%w(instant runtime local))
-    end
-
-    it 'config.layer_add(layer) return nil if layer name already exist '\
-       'in layers' do
-      config = PRC::BaseConfig.new
-      layer = PRC::CoreConfig.define_layer(:name => 'instant',
-                                           :config => config)
-      expect(@config.layers).to eq(%w(instant runtime local))
-      expect(@config.layer_add layer).to equal(nil)
-      expect(@config.layers).to eq(%w(instant runtime local))
-    end
-
-    it "config['test'] = 'toto' is added in the 'instant' layer" do
-      @config['test'] = 'toto'
-      expect(@config.where?('test')).to eq(%w(instant))
-    end
-
-    it "config.layer_remove(:name => 'instant') return true" do
-      expect(@config.layer_remove(:name => 'instant')).to equal(true)
-    end
-
-    it "config.where?('test') return false - The layer is inexistent." do
-      expect(@config.where?('test')).to equal(false)
-    end
-
-    it "config.layer_remove(:name => 'runtime') return nil"\
-       ' - Unable to remove a layer not added at runtime' do
-      expect(@config.layers).to eq(%w(runtime local))
-      expect(@config.layer_remove(:name => 'runtime')).to equal(nil)
-      expect(@config.layers).to eq(%w(runtime local))
-    end
-
-    it 'a child set(keys, value, name => "local") works.' do
-      value = { :data1 => 'test_data1', :data2 => 'test_data2' }
-      expect(@config.set(:keys => [:merge1],
-                         :value => value,
-                         :name => 'local')).to eq(value)
-      expect(@config.where?(:merge1)).to eq(%w(local))
-    end
-
-    it 'a child set(keys, value, names => ["local"]) works '\
-       'but set in runtime. :names is ignored.' do
-      value = { :data1 => 'test_data1', :data2 => 'test_data3' }
-      expect(@config.set(:keys => [:merge1],
-                         :value => value,
-                         :names => ['local'])).to eq(value)
-      expect(@config.where?(:merge1)).to eq(%w(runtime local))
-    end
-
-    it 'a child set(keys, value, name => "runtime") works.' do
-      value = { :data2 => 'value_runtime', :test_runtime => true }
-      expect(@config.set(:keys => [:merge1],
-                         :value => value,
-                         :name => 'runtime')).to eq(value)
-      expect(@config.where?(:merge1)).to eq(%w(runtime local))
-      expect(@config[:merge1]).to eq(value)
-    end
-
-    it 'a child get(keys, name) can do merge '\
-       'even with only one layer selected.' do
-      value_local = { :data1 => 'test_data1', :data2 => 'test_data2' }
-      expect(@config.get(:keys => [:merge1], :merge => true,
-                         :names => ['local'])).to eq(value_local)
-      value_runtime = { :data2 => 'value_runtime', :test_runtime => true }
-      expect(@config.get(:keys => [:merge1], :merge => true,
-                         :names => ['runtime'])).to eq(value_runtime)
-    end
-
-    context "with config[:merge1] = {:data2 => {:test_runtime => true} }\n"\
-            'and local: :merge1: => {:data1: test_data1, :data2: test_data3}' do
-      before(:all) do
-        @config[:merge1] = { :data2 => { :test_runtime => true } }
-        value = { :data1 => 'test_data1', :data2 => 'test_data3' }
-        @config.set(:keys => [:merge1], :value => value, :name => 'local')
-      end
-
-      it 'config.mergeable?(:keys => [:merge1, :data2]) return false, '\
-         'because the first found in the deepest layers is not a Hash/Array.' do
-        expect(@config.where?(:merge1, :data2)).to eq(%w(runtime local))
-        expect(@config.mergeable?(:keys => [:merge1, :data2])).to equal(false)
-      end
-
-      it 'config.mergeable?(:keys => [:merge1, :data2], '\
-         ':exclusive => true) return false '\
-         '- "runtime" layer :data2 is not a Hash' do
-        expect(@config.where?(:merge1, :data2)).to eq(%w(runtime local))
-        expect(@config.mergeable?(:keys => [:merge1, :data2],
-                                  :exclusive => true)).to equal(false)
-      end
-
-      it 'config.merge() return "test_data3" a single data, first found in '\
-         'the deepest layers.' do
-        expect(@config.merge(:merge1, :data2)).to eq('test_data3')
-      end
-    end
-
-    context "with config[:merge1] = {:data2 => :test_runtime}\n"\
-            'and local: :merge1: => {:data2 => {:test => :test_data2} }' do
-      before(:all) do
-        @config[:merge1] = { :data2 => :test_runtime }
-        value = { :data2 => { :test => :test_data2 } }
-        @config.set(:keys => [:merge1], :value => value, :name => 'local')
-      end
-
-      it 'config.mergeable?(:keys => [:merge1, :data2]) return true, '\
-         'because the first found in the deepest layers is a Hash.' do
-        expect(@config.where?(:merge1)).to eq(%w(runtime local))
-        expect(@config.mergeable?(:keys => [:merge1, :data2])).to equal(true)
-      end
-
-      it 'config.mergeable?(:keys => [:merge1, :data2], '\
-         ':exclusive => true) return false '\
-         '- "runtime" layer :data2 is not a Hash' do
-        expect(@config.mergeable?(:keys => [:merge1, :data2],
-                                  :exclusive => true)).to equal(false)
-      end
-
-      it 'config.merge() return a single data, first found in the '\
-         'deepest layers.' do
-        expect(@config.merge(:merge1, :data2)).to eq(:test => :test_data2)
-      end
-    end
-
-    context "with config[:merge1] = {:data2 => {:test_runtime => true} }\n"\
-            'and local: :merge1: => {:data2 => {:test => :test_data2} }' do
-      before(:all) do
-        @config[:merge1] = { :data2 => { :test_runtime => true } }
-        value = { :data2 => { :test => :test_data2 } }
-        @config.set(:keys => [:merge1], :value => value, :name => 'local')
-      end
-
-      it 'config.mergeable?(:keys => [:merge1, :data2]) return true, '\
-         'because the first found in the deepest layers is a Hash.' do
-        expect(@config.where?(:merge1, :data2)).to eq(%w(runtime local))
-        expect(@config.mergeable?(:keys => [:merge1, :data2])).to equal(true)
-      end
-
-      it 'config.mergeable?(:keys => [:merge1, :data2], '\
-         ':exclusive => true) return true '\
-         '- All layers data found are Hash type.' do
-        expect(@config.mergeable?(:keys => [:merge1, :data2],
-                                  :exclusive => true)).to equal(true)
-      end
-
-      it 'config.merge() return a single data, first found in the '\
-         'deepest layers.' do
-        expect(@config.merge(:merge1, :data2)).to eq(:test_runtime => true,
-                                                     :test => :test_data2)
-      end
-    end
-  end
-end