lorj 1.0.3 → 1.0.4

data/spec/09_prc_spec.rb

@@ -0,0 +1,104 @@
+#!/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'
+
+app_path = File.dirname(__FILE__)
+$LOAD_PATH << File.join(app_path, '..', 'lib')
+
+describe 'Module PrcLib: ' do
+  after(:all) do
+    Object.send(:remove_const, :PrcLib)
+    load File.join(app_path, '..', 'lib', 'prc.rb') # Load prc
+    load File.join(app_path, '..', 'lib', 'logging.rb') # Load logging
+  end
+
+  it 'load Lorj and PrcLib Modules' do
+    require 'lorj' # Load lorj framework
+    expect(Lorj).to be
+    expect(PrcLib).to be
+  end
+
+  it 'lib_path is set' do
+    file = File.expand_path(File.join(app_path, '..', 'lib'))
+    expect(PrcLib.lib_path).to eq(file)
+  end
+
+  it 'default app is lorj and cannot be updated.' do
+    expect(PrcLib.app_name).to eq('lorj')
+    PrcLib.app_name = 'lorj-spec'
+    expect(PrcLib.app_name).to eq('lorj')
+  end
+
+  it 'after load cleanup, set default app to lorj-spec is ok' do
+    Object.send(:remove_const, :PrcLib)
+    load File.join(app_path, '..', 'lib', 'prc.rb') # Load lorj framework
+    PrcLib.app_name = 'lorj-spec'
+    expect(PrcLib.app_name).to eq('lorj-spec')
+  end
+
+  it 'default pdata_path to ~/.config/lorj, and not updatable' do
+    Object.send(:remove_const, :PrcLib)
+    load File.join(app_path, '..', 'lib', 'prc.rb') # Load lorj framework
+    file = File.expand_path(File.join('~', '.config', PrcLib.app_name))
+    expect(PrcLib.pdata_path).to eq(file)
+    PrcLib.pdata_path = File.join('~', '.test')
+    expect(PrcLib.pdata_path).to eq(file)
+  end
+
+  it 'after load cleanup, set default pdata_path to ~/.test is ok.' do
+    Object.send(:remove_const, :PrcLib)
+    load File.join(app_path, '..', 'lib', 'prc.rb') # Load lorj framework
+    file = File.expand_path(File.join('~', '.test'))
+    PrcLib.pdata_path = file
+    expect(PrcLib.pdata_path).to eq(file)
+  end
+
+  it 'default data_path to ~/.config/lorj, and not updatable' do
+    Object.send(:remove_const, :PrcLib)
+    load File.join(app_path, '..', 'lib', 'prc.rb') # Load lorj framework
+    file = File.expand_path(File.join('~', '.lorj'))
+    expect(PrcLib.data_path).to eq(file)
+    PrcLib.data_path = File.join('~', '.test')
+    expect(PrcLib.data_path).to eq(file)
+  end
+
+  it 'after load cleanup, set default data_path to ~/.test is ok.' do
+    Object.send(:remove_const, :PrcLib)
+    load File.join(app_path, '..', 'lib', 'prc.rb') # Load lorj framework
+    file = File.expand_path(File.join('~', '.test'))
+    PrcLib.data_path = file
+    expect(PrcLib.data_path).to eq(file)
+  end
+
+  it 'model is initialized automatically.' do
+    expect(PrcLib.model).to be
+    expect(PrcLib.model.class).to be(Lorj::Model)
+  end
+
+  it 'app_defaults is nil (no defaults)' do
+    expect(PrcLib.app_defaults).to equal(nil)
+  end
+
+  it 'app_defaults is set and not updatable' do
+    file = File.expand_path(File.join('~', 'src', 'lorj'))
+    PrcLib.app_defaults = file
+    expect(PrcLib.app_defaults).to eq(file)
+    PrcLib.app_defaults = File.expand_path(File.join('~', '.test'))
+    expect(PrcLib.app_defaults).to eq(file)
+  end
+end

data/spec/{00_lorj_log_spec.rb → 10_lorj_log_spec.rb}

@@ -21,7 +21,7 @@
 
 app_path = File.dirname(File.dirname(__FILE__))
 
-$LOAD_PATH << './lib'
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
 # This spec HAVE to the the first one executed!
 # Do never create a file or rename this file, which will
@@ -32,6 +32,16 @@ $LOAD_PATH << './lib'
 
 describe 'Module: Lorj,' do
   context 'Initializing' do
+    before(:all) do
+      rel_name = format('lorj-%d', Process.pid)
+      @rel_path = File.join('/tmp', rel_name) if File.exist?('/tmp')
+      @rel_path = File.expand_path(File.join('~', rel_name)) if @rel_path.nil?
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(@rel_path)
+    end
+
     it 'PrcLib module exist' do
       require 'lorj' # Load lorj framework
       expect(PrcLib.class).to equal(Module)
@@ -39,8 +49,19 @@ describe 'Module: Lorj,' do
       expect(PrcLib.log).to be_nil
     end
 
+    it 'log_file = [...]/lorj-rspec.log creates the path' do
+      log = File.join(@rel_path, 'lorj-rspec.log')
+      PrcLib.log_file = log
+      expect(File.exist?(@rel_path))
+    end
+
+    it 'log_file should get absolute path to the file' do
+      log = File.join(@rel_path, 'lorj-rspec.log')
+      log = File.expand_path(log)
+      expect(PrcLib.log_file).to eq(log)
+    end
+
     it 'create PrcLib.log object at first message' do
-      PrcLib.log_file = 'lorj-rspec.log'
       PrcLib.level = Logger::FATAL
       PrcLib.app_name = 'lorj-spec'
       PrcLib.app_defaults = File.join(app_path, 'lorj-spec')

data/spec/11_lorj_config_spec.rb

@@ -15,16 +15,22 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
+#  require 'byebug'
+
 app_path = File.dirname(__FILE__)
 
-$LOAD_PATH << File.join('..', 'lib')
+$LOAD_PATH << File.join(app_path, '..', 'lib')
 
 require 'lorj' # Load lorj framework
 
 describe 'class: Lorj::Config,' do
   context 'new instance, with no default local config files, ' do
     before(:all) do
-      PrcLib.log_file = 'lorj-rspec.log'
+      log_file = File.expand_path(File.join('~', 'lorj-rspec.log'))
+      File.delete(log_file) if File.exist?(log_file)
+
+      PrcLib.log = nil
+      PrcLib.log_file = log_file
       PrcLib.level = Logger::FATAL
       PrcLib.app_name = 'lorj-spec'
       PrcLib.app_defaults = File.expand_path(File.join(app_path, '..',
@@ -67,7 +73,7 @@ describe 'class: Lorj::Config,' do
     end
 
     it 'config.layers returns all config names.' do
-      expect(@config.layers).to eq(%w(runtime local default))
+      expect(@config.layers).to eq(%w(runtime local controller default))
     end
 
     it 'config.where?(:test1) return false' do
@@ -235,29 +241,5 @@ describe 'class: Lorj::Config,' do
         expect(@config.runtime_exist?(:test1)).to equal(true)
       end
     end
-    context 'app default functions' do
-      before(:all) do
-        default_file = @config.config_filename('default')
-        @default = YAML.load_file(default_file)
-      end
-      it 'config.app_default(:default) returns :default of defaults.yaml' do
-        expect(@config.app_default(:default)).to eq(@default[:default])
-      end
-
-      it 'config.app_default(:sections) returns :section of defaults.yaml' do
-        expect(@config.app_default(:sections)).to eq(@default[:sections])
-      end
-      it 'config.meta_each provides the wanted list of section/key/values' do
-        # The defaults.yaml MUST have data exclusive set to true
-        expect(@default.rh_get(:sections, :credentials, :data,
-                               :account_exclusive)).to equal(true)
-        @config.meta_each do |section, key, value|
-          expect(@default.rh_exist?(:sections, section, key)).to equal(true)
-          expect(@default.rh_get(:sections, section, key)).to equal(value)
-          expect([section, key,
-                  value]).not_to eq([:sections, :credentials, :data])
-        end
-      end
-    end
   end
 end

data/spec/12_lorj_account_spec.rb

@@ -15,13 +15,11 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-# require 'rubygems'
-# require 'byebug'
-# require 'bundler/setup'
+#  require 'byebug'
 
-app_path = File.dirname(File.dirname(__FILE__))
+app_path = File.dirname(__FILE__)
 
-$LOAD_PATH << '../lib'
+$LOAD_PATH << File.join(app_path, '..', 'lib')
 
 require 'lorj' # Load lorj framework
 
@@ -31,7 +29,7 @@ describe 'class: Lorj::Account,' do
       PrcLib.log_file = 'lorj-rspec.log'
       PrcLib.level = Logger::FATAL
       PrcLib.app_name = 'lorj-spec'
-      PrcLib.app_defaults = File.join(app_path, 'lorj-spec')
+      PrcLib.app_defaults = File.join(app_path, '..', 'lorj-spec')
 
       account = Lorj::Account.new
       expect(account).to be
@@ -39,7 +37,7 @@ describe 'class: Lorj::Account,' do
 
     it 'account.layers is compliant' do
       account = Lorj::Account.new
-      expect(account.layers).to eq(%w(runtime account local default))
+      expect(account.layers).to eq(%w(runtime account local controller default))
     end
   end
 
@@ -55,7 +53,8 @@ describe 'class: Lorj::Account,' do
       File.open(File.join(PrcLib.data_path, 'accounts', 'test1'),
                 'w+') do |file|
         file.write(":credentials:\n  :keypair_name: nova_test1\n  "\
-                   ":tenant_name: test\n  :data: ac_data")
+                   ":tenant_name: test\n  :data: ac_data\n:account:\n  "\
+                   ":name: test1\n  :provider: myprovider\n")
       end
 
       @account = Lorj::Account.new
@@ -178,23 +177,12 @@ describe 'class: Lorj::Account,' do
                           :name => 'account')).to eq('nova_test2')
     end
 
-    it 'account.ac_save return false - '\
-       'file has no valid provider name' do
-      expect(@account.ac_save).to equal(false)
-    end
-
-    it 'set provider name' do
-      expect(@account.set(:provider, 'myprovider',
-                          :name => 'account',
-                          :section => :account)).to eq('myprovider')
-    end
-
     it 'account.ac_save return true' do
       expect(@account.ac_save).to equal(true)
     end
 
     it 'account.ac_new return true, and :data disappeared.' do
-      expect(@account.ac_new 'test1').to equal(true)
+      expect(@account.ac_new 'test1', 'provider').to equal(true)
       expect(@account.where?(:data)).to eq(%w(runtime))
     end
 
@@ -209,4 +197,32 @@ describe 'class: Lorj::Account,' do
                           :name => 'account')).to eq('nova_test2')
     end
   end
+
+  context "Key      | runtime | accounts   | local     | default)\n"\
+          "  :keypair | nil     | nil        | nova_local| default_key\n"\
+          "  :data    | nil     | nil        | no effect | None\n"\
+          "  :data is account exclusive\n  => accounts/test1 not set:" do
+    before(:all) do
+      File.open(File.join(PrcLib.data_path, 'config.yaml'),
+                'w+') do |file|
+        file.write(":default:\n  :keypair_name: nova_local\n  :data: no effect")
+      end
+      File.open(File.join(PrcLib.data_path, 'accounts', 'test1'),
+                'w+') do |file|
+        file.write(":credentials:\n  :keypair_name: nova_test1\n  "\
+                   ":tenant_name: test\n  :data: ac_data\n")
+      end
+
+      @account = Lorj::Account.new
+    end
+
+    it 'account.load return true' do
+      expect(@account.ac_load 'test1').to equal(true)
+      expect(@account.where?(:data)).to eq(%w(account))
+    end
+
+    it 'account.ac_save return false - provider not set.' do
+      expect(@account.ac_save).to equal(false)
+    end
+  end
 end

data/spec/20_lorj_meta_spec.rb

@@ -0,0 +1,271 @@
+#!/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 'rubygems'
+#  require 'byebug'
+# require 'bundler/setup'
+
+app_path = File.dirname(__FILE__)
+
+$LOAD_PATH << File.join(app_path, '..', 'lib')
+
+require 'lorj' # Load lorj framework
+
+describe 'Lorj::MetaAppConfig,' do
+  context 'core with sample initialized,' do
+    before(:all) do
+      data = <<YAMLDOC
+---
+:setup:
+  :ask_step:
+  - :desc: 'Small description'
+    :explanation: |-
+      My complete explanation is in
+      multiple lines <%= config['text'] %>
+    :add:
+    - :key_pair_files
+    - :ssh_user
+:sections:
+  :section1:
+    :data1:
+      :option1: value1
+    :data2:
+      :option1: value2
+  :section2:
+    :data2:
+      :option2: value3
+  :section3:
+    :data3:
+      :option3: value4
+YAMLDOC
+      # MetaAppConfig spec class.
+      class MetaAppConfigSpec < Lorj::MetaAppConfig
+        def get(options)
+          p_get(options)
+        end
+      end
+
+      @metadata = MetaAppConfigSpec.new YAML.load(data)
+    end
+
+    it 'sections returns [:section1, :section2].' do
+      expect(@metadata.sections).to eq([:section1, :section2, :section3])
+    end
+
+    it 'sections(:data1) returns [:section1].' do
+      expect(@metadata.sections(:data1)).to eq([:section1])
+    end
+
+    it 'sections(:data2) returns [:section1, :section2].' do
+      expect(@metadata.sections(:data2)).to eq([:section1, :section2])
+    end
+
+    it 'datas returns [:data1, :data2].' do
+      expect(@metadata.datas).to eq([:data1, :data2, :data3])
+    end
+
+    it 'first_section(:data2) returns :section1' do
+      expect(@metadata.first_section(:data2)).to equal(:section1)
+    end
+
+    it 'first_section(:data1) returns :section1' do
+      expect(@metadata.first_section(:data1)).to equal(:section1)
+    end
+
+    it 'first_section(:data3) returns :section3' do
+      expect(@metadata.first_section(:data3)).to equal(:section3)
+    end
+
+    it 'meta_exist?(:section1, :data1) returns true' do
+      expect(@metadata.meta_exist?(:section1, :data1)).to equal(true)
+    end
+
+    it 'meta_exist?(:section2, :data1) returns false' do
+      expect(@metadata.meta_exist?(:section2, :data1)).to equal(false)
+    end
+
+    it 'meta_exist?(:section2, :data2) returns true' do
+      expect(@metadata.meta_exist?(:section2, :data2)).to equal(true)
+    end
+
+    it 'auto_meta_exist?(:data2) returns true' do
+      expect(@metadata.auto_meta_exist?(:data2)).to equal(true)
+    end
+
+    it 'auto_meta_exist?(:data3) returns true' do
+      expect(@metadata.auto_meta_exist?(:data3)).to equal(true)
+    end
+
+    it 'auto_meta_exist?(:data4) returns false' do
+      expect(@metadata.auto_meta_exist?(:data4)).to equal(false)
+    end
+
+    it 'meta_each provides list of section/key/values' do
+      @metadata.meta_each do |section, key, _values|
+        expect(@metadata.sections.include?(section))
+        expect(@metadata.datas.include?(key))
+      end
+    end
+    it 'parent data[:sections, :section5, :data5] returns nil' do
+      expect(@metadata[:sections, :section5, :data5]).to equal(nil)
+    end
+
+    it 'data[:sections, :section5, :data5] = {:option5 => value5}' do
+      @metadata[:sections, :section5, :data5] = { :option5 => :value5 }
+      expect(@metadata[:sections, :section5, :data5]).to eq(:option5 => :value5)
+      option = {}
+      option[:keys] = [:sections, :section5, :data5, :option5]
+      option[:name] = 'app'
+      expect(@metadata.get(option)).to equal(nil)
+      option[:name] = 'map'
+      expect(@metadata.get(option)).to equal(nil)
+
+      # section mapping should be updated.
+      expect(@metadata.sections(:data5)).to eq([:section5])
+    end
+
+    # To simplify spec code, app layer contains String values for each options
+    # while controller options values are Symbol.
+    # This helps to identify if the merge feature result.
+    it 'define_controller_data(:section2, :data2, :option2 => :value4) works' do
+      data = { :option2 => :value4 }
+      expect(@metadata[:sections, :section2, :data2, :option2]).to eq('value3')
+      expect(@metadata.define_controller_data(:section2,
+                                              :data2, data)).to eq(data)
+      expect(@metadata.sections(:data2)).to eq([:section1, :section2])
+      expect(@metadata[:sections, :section2, :data2, :option2]).to eq(:value4)
+    end
+
+    it 'update_controller_data(:section2, :data2, :option3 => value1) works' do
+      data = { :option3 => :value1 }
+      result = data.clone
+      result[:option2] = :value4
+      expect(@metadata.update_controller_data(:section2,
+                                              :data2, data)).to eq(result)
+      expect(@metadata[:sections, :section2, :data2, :option2]).to eq(:value4)
+      expect(@metadata[:sections, :section2, :data2, :option3]).to eq(:value1)
+    end
+
+    it 'section_data(:section1, :data1) returns {:option1 => "value1"}' do
+      expect(@metadata.section_data(:section1, :data1
+                                   )).to eq(:option1 => 'value1')
+    end
+
+    it 'section_data(:section1, :data1, :option1) returns "value1"' do
+      expect(@metadata.section_data(:section1, :data1,
+                                    :option1)).to eq('value1')
+    end
+
+    it 'section_data(:section2, :data2) returns Merged hash' do
+      expect(@metadata.section_data(:section2, :data2
+                                   )).to eq(:option2 => :value4,
+                                            :option3 => :value1)
+      # Expect no change (internal reverse is not impacting)
+      expect(@metadata.section_data(:section2, :data2
+                                   )).to eq(:option2 => :value4,
+                                            :option3 => :value1)
+      # 'App' option value already exists and has not been updated.
+      option = {}
+      option[:keys] = [:sections, :section2, :data2, :option2]
+      option[:name] = 'app'
+      expect(@metadata.get(option)).to eq('value3')
+    end
+
+    it 'With :section3 => :data3 => :option1 => :value1,'\
+       ' section_data(:section3, :data3) returns {:option1=>:value1,'\
+       ':option3=> "value4"}' do
+      @metadata.define_controller_data(:section3,
+                                       :data3, :option1 => :value1)
+      expect(@metadata.section_data(:section3, :data3
+                                   )).to eq(:option1 => :value1,
+                                            :option3 => 'value4')
+    end
+
+    it 'auto_section_data(:data3) returns {:option1=>:value1,'\
+       ':option3=> "value4"}' do
+      expect(@metadata.auto_section_data(:data3)).to eq(:option1 => :value1,
+                                                        :option3 => 'value4')
+    end
+
+    it 'set(:sections, :section6, :data6, {:option6 => :value6}) returns '\
+       ':option6 => :value6' do
+      expect(@metadata.set(:sections, :section6, :data6,
+                           :option6 => :value6)).to eq(:option6 => :value6)
+
+      option = {}
+      option[:keys] = [:sections, :section6, :data6, :option6]
+      option[:name] = 'app'
+      expect(@metadata.get(option)).to equal(nil)
+      option[:name] = 'map'
+      expect(@metadata.get(option)).to equal(nil)
+      option[:name] = 'controller'
+      expect(@metadata.get(option)).to eq(:value6)
+      expect(@metadata.sections(:data6)).to eq([:section6])
+    end
+
+    it 'set(:sections, :section6, :data6, {:option6 => :value7}, "app") '\
+       'returns :option6 => :value7. but controller is only updated.' do
+      expect(@metadata.set(:sections, :section6, :data6,
+                           { :option6 => :value7 },
+                           'app')).to eq(:option6 => :value7)
+
+      option = {}
+      option[:keys] = [:sections, :section6, :data6, :option6]
+      option[:name] = 'app'
+      expect(@metadata.get(option)).to equal(nil)
+      option[:name] = 'map'
+      expect(@metadata.get(option)).to equal(nil)
+      option[:name] = 'controller'
+      expect(@metadata.get(option)).to eq(:value7)
+    end
+
+    it 'set(:any, :kind_of, :data1, {:option1 => :value1}) '\
+       'returns :option1 => :value1' do
+      expect(@metadata.where?(:any, :kind_of, :data1, :option1)).to equal(false)
+      expect(@metadata.set(:any, :kind_of, :data1, :option1 => :value1
+                           )).to eq(:option1 => :value1)
+      expect(@metadata.where?(:any, :kind_of, :data1,
+                              :option1)).to eq(['controller'])
+    end
+
+    it 'del(:any, :kind_of, :data1) returns :option1 => :value1 and '\
+       'is deleted' do
+      expect(@metadata.del(:any, :kind_of, :data1)).to eq(:option1 => :value1)
+
+      expect(@metadata.where?(:any, :kind_of, :data1, :option1)).to equal(false)
+    end
+
+    it 'setup_options(:ask_step) returns a merged data' do
+      expect(@metadata.setup_options(:ask_step).class).to equal(Array)
+      expect(@metadata.setup_options(:ask_step).length).to equal(1)
+    end
+
+    it 'setup_data(:ask_step) returns a merged data' do
+      data = @metadata.setup_data(:ask_step)
+      expect(data.class).to equal(Array)
+      expect(data.length).to equal(1)
+    end
+  end
+
+  context 'from Lorj.data,' do
+    it 'gets loaded.' do
+      PrcLib.level = Logger::FATAL
+      expect(Lorj.data).to be
+      expect(Lorj.data.class).to equal(Lorj::MetaAppConfig)
+    end
+  end
+end

data/spec/21_lorj_defaults_spec.rb

@@ -0,0 +1,85 @@
+#!/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 'rubygems'
+#  require 'byebug'
+# require 'bundler/setup'
+
+app_path = File.dirname(__FILE__)
+
+$LOAD_PATH << File.join(app_path, '..', 'lib')
+
+require 'lorj' # Load lorj framework
+
+describe 'class: Lorj::Default loaded lorj_spec/defaults.yaml, '\
+         'no controller data,' do
+  context 'from PrcLib module,' do
+    before(:all) do
+      log_file = File.expand_path(File.join('~', 'lorj-rspec.log'))
+      File.delete(log_file) if File.exist?(log_file)
+
+      PrcLib.log_file = log_file
+      PrcLib.level = Logger::FATAL
+      PrcLib.app_name = 'lorj-spec'
+      PrcLib.app_defaults = File.expand_path(File.join(app_path, '..',
+                                                       'lorj-spec'))
+    end
+
+    it 'PrcLib.defaults returns a Lorj::Defaults instance.' do
+      expect(Lorj.defaults).to be
+      expect(Lorj.defaults.class).to equal(Lorj::Defaults)
+    end
+  end
+
+  context 'Default instance' do
+    before(:all) do
+      @defaults = Lorj.defaults
+    end
+
+    context 'Features to be removed at version 2.0,' do
+      # TODO: Feature to be removed at version 2.0.
+      it 'meta_each provides list of section/key/values' do
+        @defaults.meta_each do |section, key, values|
+          expect([:credentials, :maestro].include?(section))
+          expect([:keypair_name, :data, :maestro_url].include?(key))
+          expect([nil, { :account_exclusive => true }].include?(values))
+        end
+      end
+
+      it 'meta_exist?(:data) return true' do
+        expect(@defaults.meta_exist?(:data)).to equal(true)
+      end
+
+      it 'meta_exist?(:test1) return false' do
+        expect(@defaults.meta_exist?(:test1)).to equal(false)
+      end
+
+      it 'get_meta_auto(:data) return {:account_exclusive => true}' do
+        expect(@defaults.get_meta_auto(:data)).to eq(:account_exclusive => true)
+      end
+
+      it 'get_meta(:credentials, :data) return {:account_exclusive => true}' do
+        expect(@defaults.get_meta(:credentials,
+                                  :data)).to eq(:account_exclusive => true)
+      end
+
+      it 'get_meta_section(:data) return :credentials' do
+        expect(@defaults.get_meta_section(:data)).to eq(:credentials)
+      end
+    end
+  end
+end