lorj 1.0.10 → 1.0.11

data/lorj-spec/providers_extra/mock3/mock3.rb

@@ -0,0 +1,144 @@
+# 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.
+
+# This class describes how to process some actions, and will do everything prior
+# this task to make it to work.
+
+# This Mock controller keep the data in memory in hash/Array data.
+class Mock
+  # mock do not need to use any mapping. It adapts itself to what the process
+  # has defined.
+end
+
+# This Mock controller keep the data in memory in hash/Array data.
+class MockController
+  @@data = {} # rubocop: disable ClassVars
+
+  def create(sObjectType, hParams)
+    PrcLib.debug("Mock: create object '%s' with parameters (hdata) '%s'",
+                 sObjectType, hParams[:hdata])
+
+    result = {}
+    hParams[].keys.each do |key|
+      next if key == :hdata
+      result[key] = hParams[key]
+    end
+    result.merge!(hParams[:hdata])
+
+    @@data[sObjectType] = [] unless @@data.key?(sObjectType)
+
+    array = @@data[sObjectType]
+
+    array.each do |value|
+      fail if value.key?(result[:name])
+    end
+    array << result
+
+    result[:id] = array.length - 1
+
+    # Typical code:
+    # ~ case sObjectType
+    # ~ when :public_ip
+    # Following function can be executed to ensure the object :connection exists
+    # ~ required?(hParams, :connection)
+    # ~ required?(hParams, :server)
+    # ~ ... CODE to create
+    # ~ else
+    # ~ controller_error "'%s' is not a valid object for 'create'", sObjectType
+    # ~ end
+    # The code should return some data
+    # This data will be encapsulated in Lorj::Data object.
+    # data will be extracted by the framework with the controller get_attr
+    # function and mapped.
+    PrcLib.debug("Mock: object '%s' = '%s' is created.", sObjectType, result)
+    result
+  end
+
+  # This function return a collection which have to provide:
+  # functions: [], length, each
+  # Used by network process.
+  def query(sObjectType, sQuery, hParams)
+    PrcLib.debug("Mock: query object '%s' with hdata '%s' using query '%s'",
+                 sObjectType, hParams[:hdata], sQuery)
+
+    return [] unless @@data.key?(sObjectType)
+
+    result = []
+
+    @@data[sObjectType].each do |value|
+      elem = value
+      sQuery.each do |query_key, query_value|
+        elem = nil if !value.key?(query_key) || value[query_key] != query_value
+      end
+      result << elem if elem
+    end
+    result
+  end
+
+  def delete(sObjectType, hParams)
+    PrcLib.debug("Mock: delete object '%s' with hdata '%s'",
+                 sObjectType, hParams[:hdata])
+    return nil unless @@data.key?(sObjectType)
+
+    return false if !hParams.exist?(sObjectType) || hParams[sObjectType].nil?
+    @@data[sObjectType].delete(hParams[sObjectType])
+    PrcLib.debug("Mock: object '%s' = '%s' is deleted.",
+                 sObjectType, hParams[sObjectType])
+    true
+  end
+
+  def get(sObjectType, sUniqId, hParams)
+    PrcLib.debug("Mock: Get object '%s' = '%s' with hdata '%s'",
+                 sObjectType, sUniqId, hParams[:hdata])
+    return nil unless @@data.key?(sObjectType)
+    @@data[sObjectType][sUniqId]
+  end
+
+  def get_attr(oControlerObject, key)
+    # This controller function read the data and
+    # extract the information requested by the framework.
+    # Those data will be mapped to the process data model.
+    # The key is an array, to get data from a level tree.
+    # [data_l1, data_l2, data_l3] => should retrieve data from structure like
+    # data[ data_l2[ data_l3 ] ]
+    attributes = oControlerObject
+
+    attributes.rh_get(key)
+ rescue => e
+   controller_error "Unable to map '%s'.\n%s", key, e.message
+  end
+
+  def set_attr(oControlerObject, key, value)
+    attributes = oControlerObject
+
+    attributes.rh_set(value, key)
+ rescue => e
+   controller_error "Unable to map '%s' on '%s'.\n%s",
+                    key, sObjectType, e.message
+  end
+
+  def update(sObjectType, oObject, hParams)
+    PrcLib.debug("Mock: Update object '%s' = '%s' with hdata '%s'",
+                 sObjectType, sUniqId, hParams[:hdata])
+    return false unless @@data.key?(sObjectType)
+
+    return false unless @@data[sObjectType][oObject[:id]].nil?
+    # Considered hash object is already updated.
+    # This action emule the object save which doesn't make sense in this empty
+    # Mock controller.
+    true
+  end
+end

data/lorj.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
     '--title Lorj - The Process Controllers framework system' << \
     '--main README.md'
 
-  spec.add_runtime_dependency 'config_layers', '~>0.1.0'
+  spec.add_runtime_dependency 'config_layers', '~>0.1.3'
   #  spec.add_runtime_dependency 'git', '>=1.2.7'
   #  spec.add_runtime_dependency 'rbx-require-relative', '~>0.0.7'
   spec.add_runtime_dependency 'highline', '~> 1.6.21'

data/spec/05_lorj_keypath_spec.rb

@@ -15,7 +15,7 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-# require 'byebug'
+#    require 'byebug'
 
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib/core')
 
@@ -26,6 +26,9 @@ describe 'Lorj::KeyPath,' do
     before(:all) do
       @o_key = Lorj::KeyPath.new(:test)
     end
+    it 'Test method #length' do
+      expect(@o_key.length).to eq(1)
+    end
     it 'Test method #to_s' do
       expect(@o_key.to_s).to eq('test')
     end
@@ -45,7 +48,7 @@ describe 'Lorj::KeyPath,' do
       expect(@o_key.key).to eq(:test)
     end
     it 'Test method #key_tree' do
-      expect(@o_key.key).to eq(:test)
+      expect(@o_key.key_tree).to eq(:test)
     end
   end
 
@@ -53,6 +56,9 @@ describe 'Lorj::KeyPath,' do
     before(:all) do
       @o_key = Lorj::KeyPath.new([:test, :test2, :test3])
     end
+    it 'Test method #length' do
+      expect(@o_key.length).to eq(3)
+    end
     it 'Test method #to_s' do
       expect(@o_key.to_s).to eq('test/test2/test3')
     end
@@ -75,4 +81,124 @@ describe 'Lorj::KeyPath,' do
       expect(@o_key.key_tree).to eq(':test/:test2/:test3')
     end
   end
+
+  context 'initialize with string test1/test2' do
+    before(:all) do
+      @o_key = Lorj::KeyPath.new('test1/test2')
+    end
+    it 'Test method #length' do
+      expect(@o_key.length).to eq(2)
+    end
+    it 'Test method #to_s' do
+      expect(@o_key.to_s).to eq('test1/test2')
+    end
+    it 'Test method #key' do
+      expect(@o_key.key).to eq('test2')
+    end
+    it 'Test method #key(0)' do
+      expect(@o_key.key(0)).to eq('test1')
+    end
+    it 'Test method #key(1)' do
+      expect(@o_key.key(1)).to eq('test2')
+    end
+    it 'Test method #fpath' do
+      expect(@o_key.fpath).to eq('test1/test2')
+    end
+    it 'Test method #tree' do
+      expect(@o_key.tree).to eq(%w(test1 test2))
+    end
+    it 'Test method #key_tree' do
+      expect(@o_key.key_tree).to eq('test1/test2')
+    end
+  end
+
+  context 'initialize with string :test' do
+    before(:all) do
+      @o_key = Lorj::KeyPath.new(':test')
+    end
+    it 'Test method #length' do
+      expect(@o_key.length).to eq(1)
+    end
+    it 'Test method #to_s' do
+      expect(@o_key.to_s).to eq('test')
+    end
+    it 'Test method #key' do
+      expect(@o_key.key).to eq(:test)
+    end
+    it 'Test method #key(0)' do
+      expect(@o_key.key(0)).to eq(:test)
+    end
+    it 'Test method #key(1)' do
+      expect(@o_key.key(1)).to eq(nil)
+    end
+    it 'Test method #fpath' do
+      expect(@o_key.fpath).to eq(':test')
+    end
+    it 'Test method #tree' do
+      expect(@o_key.tree).to eq([:test])
+    end
+    it 'Test method #key_tree' do
+      expect(@o_key.key_tree).to eq(:test)
+    end
+  end
+
+  context 'initialize with string test' do
+    before(:all) do
+      @o_key = Lorj::KeyPath.new('test')
+    end
+    it 'Test method #length' do
+      expect(@o_key.length).to eq(1)
+    end
+    it 'Test method #to_s' do
+      expect(@o_key.to_s).to eq('test')
+    end
+    it 'Test method #key' do
+      expect(@o_key.key).to eq('test')
+    end
+    it 'Test method #key(0)' do
+      expect(@o_key.key(0)).to eq('test')
+    end
+    it 'Test method #key(1)' do
+      expect(@o_key.key(1)).to eq(nil)
+    end
+    it 'Test method #fpath' do
+      expect(@o_key.fpath).to eq('test')
+    end
+    it 'Test method #tree' do
+      expect(@o_key.tree).to eq(['test'])
+    end
+    it 'Test method #key_tree' do
+      expect(@o_key.key_tree).to eq('test')
+    end
+  end
+
+  context 'initialize with nil' do
+    before(:all) do
+      @o_key = Lorj::KeyPath.new(nil)
+    end
+    it 'Test method #length' do
+      expect(@o_key.length).to eq(0)
+    end
+    it 'Test method #to_s' do
+      expect(@o_key.to_s).to eq(nil)
+    end
+    it 'Test method #key' do
+      expect(@o_key.key).to eq(nil)
+    end
+    it 'Test method #key(0)' do
+      expect(@o_key.key(0)).to eq(nil)
+    end
+    it 'Test method #key(1)' do
+      expect(@o_key.key(1)).to eq(nil)
+    end
+    it 'Test method #fpath' do
+      expect(@o_key.fpath).to eq(nil)
+    end
+    it 'Test method #tree' do
+      expect(@o_key.tree).to eq([])
+    end
+    it 'Test method #key_tree' do
+      expect(@o_key.key_tree).to eq(nil)
+    end
+  end
 end

data/spec/06_lorj_object_data_spec.rb

@@ -0,0 +1,77 @@
+#!/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/core')
+
+require 'core_object_data'
+require 'subhash'
+require 'lorj_data'
+
+describe 'Lorj::ObjectData' do
+  context 'initialize with internal false' do
+    before(:all) do
+      @obj_data = Lorj::ObjectData.new
+      @obj_data[[:key1]] = 'value1'
+      @obj_data[[:key2, :key22]] = 'value2'
+    end
+    it 'Test method #[]' do
+      expect(@obj_data[[:key1]]).to eq('value1')
+      expect(@obj_data[[:key2, :key22]]).to eq('value2')
+    end
+    it 'Test method #exist?' do
+      expect(@obj_data.exist?(:key1)).to eq(true)
+      expect(@obj_data.exist?([:key2, :key22])).to eq(true)
+      expect(@obj_data.exist?(:otherkey)).to eq(false)
+    end
+    it 'Test method #<<' do
+      h_hash = { :key3 => [:key31, :key32] }
+      @obj_data.<< h_hash
+      expect(@obj_data[[:key3]]).to eq([:key31, :key32])
+    end
+    it 'Test method #to_s' do
+      expect(@obj_data.to_s).to eq('-- Lorj::ObjectData --
+hdata:
+{}
+key1:
+value1
+key2:
+{:key22=>"value2"}
+key3:
+[:key31, :key32]
+')
+    end
+  end
+  context 'initialize with internal true' do
+    before(:all) do
+      @obj_data = Lorj::ObjectData.new(true)
+      @internal_data = Lorj::Data.new
+      data = [{ :name => 'toto' }]
+      @internal_data.set(data, :list, :name => /^t/) { |oObject| oObject }
+    end
+    it 'Test method #add' do
+      @obj_data.add(@internal_data)
+      expect(@obj_data.exist?(:list)).to eq(true)
+    end
+    it 'Test method #delete' do
+      deleted_data = @obj_data.delete(@internal_data)
+      expect(@obj_data.exist?(:list)).to eq(false)
+      expect(deleted_data.is_registered).to eq(false)
+    end
+  end
+end

data/spec/13_lorj_account_spec.rb

@@ -116,6 +116,7 @@ describe 'class: Lorj::Account,' do
     it "account[:data] return 'nova_local', stored only in local." do
       expect(@account[:data]).to eq(nil)
     end
+
     it 'account.where?(:data) return false, as account not loaded.' do
       expect(@account.where?(:data)).to equal(false)
     end
@@ -220,6 +221,72 @@ describe 'class: Lorj::Account,' do
       expect(@account.get(:keypair_name, nil,
                           :name => 'account')).to eq('nova_test2')
     end
+
+    context ':credentials as section name and runtime set' do
+      it 'account.get(:"credentials#keypair_name") return '\
+         '"nova_test3"(runtime)' do
+        expect(@account.get(:"credentials#keypair_name")).to eq('nova_test3')
+      end
+
+      it 'account.get(:keypair_name, nil, :section => :credentials) '\
+         'return "nova_test3"(runtime)' do
+        expect(@account.get(:keypair_name, nil,
+                            :section => :credentials)).to eq('nova_test3')
+      end
+    end
+
+    context 'with section, no runtime' do
+      before(:all) do
+        @account.del(:keypair_name)
+      end
+
+      it 'account.get(:"credentials#keypair_name") return '\
+         '"nova_test2"(account)' do
+        expect(@account.get(:"credentials#keypair_name")).to eq('nova_test2')
+      end
+
+      it 'account.get(:keypair_name, nil, :section => :credentials) '\
+         'return "nova_test2"(account)' do
+        expect(@account.get(:keypair_name, nil,
+                            :section => :credentials)).to eq('nova_test2')
+      end
+
+      it 'account.get(:"test#keypair_name") return "nova_local"(local)' do
+        expect(@account.get(:"test#keypair_name")).to eq('nova_local')
+      end
+
+      it 'account.get(:keypair_name, nil, :section => :test) '\
+         'return "nova_local"(local)' do
+        expect(@account.get(:keypair_name, nil,
+                            :section => :test)).to eq('nova_local')
+      end
+
+      it 'account.where?(:"credentials#keypair_name") return %w(account local '\
+         'default)' do
+        expect(@account.where?('credentials#keypair_name'
+                              )).to eq(%w(account local default))
+      end
+
+      it 'account.where?(:"test#keypair_name") return %w(local '\
+         'default)' do
+        expect(@account.where?('test#keypair_name'
+                              )).to eq(%w(local default))
+      end
+    end
+
+    context 'Setting a new section, no runtime' do
+      it 'account.set(:"test#keypair_name", "nova_test3",'\
+         ':name => "account") return "nova_test3"(account)' do
+        expect(@account.set('test#keypair_name', 'nova_test3',
+                            :name => 'account')).to eq('nova_test3')
+      end
+
+      it 'account.where?(:"test#keypair_name") return %w(account local '\
+         'default)' do
+        expect(@account.where?('test#keypair_name'
+                              )).to eq(%w(account local default))
+      end
+    end
   end
 
   context "Key      | runtime | accounts   | local     | default)\n"\

data/spec/20_lorj_meta_spec.rb

@@ -78,16 +78,26 @@ YAMLDOC
       expect(@metadata.datas).to eq([:data1, :data2, :data3])
     end
 
-    it 'first_section(:data2) returns :section1' do
-      expect(@metadata.first_section(:data2)).to equal(:section1)
+    it 'first_section(:data2) returns [:section1, :data2]' do
+      expect(@metadata.first_section(:data2)).to eq([:section1, :data2])
     end
 
-    it 'first_section(:data1) returns :section1' do
-      expect(@metadata.first_section(:data1)).to equal(:section1)
+    it 'first_section("section2#data2") returns [:section2, :data2]' do
+      expect(@metadata.first_section('section2#data2')
+            ).to eq([:section2, :data2])
     end
 
-    it 'first_section(:data3) returns :section3' do
-      expect(@metadata.first_section(:data3)).to equal(:section3)
+    it 'first_section("section3#data2") returns [:section3, :data2]' do
+      expect(@metadata.first_section('section3#data2')
+            ).to eq([:section3, :data2])
+    end
+
+    it 'first_section(:data1) returns [:section1, :data1]' do
+      expect(@metadata.first_section(:data1)).to eq([:section1, :data1])
+    end
+
+    it 'first_section(:data3) returns [:section3, :data3]' do
+      expect(@metadata.first_section(:data3)).to eq([:section3, :data3])
     end
 
     it 'meta_exist?(:section1, :data1) returns true' do
@@ -140,7 +150,7 @@ YAMLDOC
 
     # 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.
+    # This helps to identify if the merge works.
     it 'define_controller_data(:section2, :data2, :option2 => :value4) works' do
       data = { :option2 => :value4 }
       expect(@metadata[:sections, :section2, :data2, :option2]).to eq('value3')

data/spec/21_lorj_processes_spec.rb

@@ -27,7 +27,7 @@ $LOAD_PATH << File.join(app_path, '..', 'lib')
 require 'lorj' # Load lorj framework
 
 describe 'Lorj::Process,' do
-  context 'with mock initialized,' do
+  context 'Lorj::ProcessResource,' do
     before(:all) do
       @lorj_spec = 'lorj-spec'
       @process_path = File.expand_path(File.join(app_path, '..', @lorj_spec))
@@ -35,13 +35,11 @@ describe 'Lorj::Process,' do
 
     it 'default initialization is ok' do
       process_file = File.join(@process_path, 'process', 'mock_process.rb')
-      controllers = { 'mock' => File.join(@process_path, 'controllers',
-                                          'mock', 'mock.rb') }
-      default = File.join(@process_path, 'defaults.yaml')
-      data = File.join(@process_path, 'data.yaml')
-      process_data = Lorj::ProcessResource.new('mock', File.join(app_path,
-                                                                 '..',
-                                                                 @lorj_spec))
+      controllers = { 'mock' => File.join(@process_path, 'process', 'mock',
+                                          'controllers', 'mock', 'mock.rb') }
+      default = File.join(@process_path, 'process', 'mock', 'defaults.yaml')
+      data = File.join(@process_path, 'process', 'mock', 'data.yaml')
+      process_data = Lorj::ProcessResource.new('mock', @process_path)
       expect(process_data).to be
       expect(process_data.name).to eq('mock')
       expect(process_data.process).to eq(process_file)
@@ -62,12 +60,11 @@ describe 'Lorj::Process,' do
 
     it 'accepts symbol as name, but converted.' do
       process_file = File.join(@process_path, 'process', 'mock_process.rb')
-      controllers = { 'mock' => File.join(@process_path, 'controllers',
-                                          'mock', 'mock.rb') }
-      default = File.join(@process_path, 'defaults.yaml')
-      data = File.join(@process_path, 'data.yaml')
-      process_data = Lorj::ProcessResource.new(:mock, File.join(app_path, '..',
-                                                                @lorj_spec))
+      controllers = { 'mock' => File.join(@process_path, 'process', 'mock',
+                                          'controllers', 'mock', 'mock.rb') }
+      default = File.join(@process_path, 'process', 'mock', 'defaults.yaml')
+      data = File.join(@process_path, 'process', 'mock', 'data.yaml')
+      process_data = Lorj::ProcessResource.new(:mock, @process_path)
       expect(process_data).to be
       expect(process_data.name).to eq('mock')
       expect(process_data.process).to eq(process_file)
@@ -77,19 +74,48 @@ describe 'Lorj::Process,' do
     end
 
     it 'initialization with :controllers_dir is ok' do
-      process_file = File.join(@process_path, 'process', 'mock_process.rb')
-      controllers = { 'mock2' => File.join(@process_path, 'providers',
-                                           'mock2', 'mock2.rb') }
-      default = File.join(@process_path, 'defaults.yaml')
-      data = File.join(@process_path, 'data.yaml')
+      controllers = { 'mock2' => File.join(@process_path, 'process', 'mock',
+                                           'providers', 'mock2', 'mock2.rb') }
+
       process_data = Lorj::ProcessResource.new('mock', @process_path,
                                                :controllers_dir => 'providers')
       expect(process_data).to be
       expect(process_data.name).to eq('mock')
-      expect(process_data.process).to eq(process_file)
       expect(process_data.controllers).to eq(controllers)
-      expect(process_data.defaults_file).to eq(default)
-      expect(process_data.data_file).to eq(data)
+    end
+
+    it 'initialization with :controllers_path is ok' do
+      controller_path = File.join(@process_path, 'providers_extra')
+      controllers = { 'mock3' => File.join(controller_path,
+                                           'mock3', 'mock3.rb') }
+      process_data = Lorj::ProcessResource.new('mock', @process_path,
+                                               :controllers_path =>
+                                                 controller_path)
+      expect(process_data).to be
+      expect(process_data.controllers).to eq(controllers)
+    end
+
+    it 'initialization with :default_file is ok' do
+      defaults_file = File.join(@process_path, 'defaults.yaml')
+      process_data = Lorj::ProcessResource.new('mock', @process_path,
+                                               :defaults_file => defaults_file)
+      expect(process_data).to be
+      expect(process_data.defaults_file).to eq(defaults_file)
+    end
+
+    it 'initialization with :data_file is ok' do
+      data_file = File.join(@process_path, 'process', 'mock', 'data.yaml')
+      process_data = Lorj::ProcessResource.new('mock', @process_path,
+                                               :data_file => data_file)
+      expect(process_data).to be
+      expect(process_data.data_file).to eq(data_file)
+    end
+  end
+
+  context('Lorj.declare_process, ') do
+    before(:all) do
+      @lorj_spec = 'lorj-spec'
+      @process_path = File.expand_path(File.join(app_path, '..', @lorj_spec))
     end
 
     it 'can declare a module process' do
@@ -101,12 +127,17 @@ describe 'Lorj::Process,' do
       expect(Lorj.processes['mock'].class).to equal(Lorj::ProcessResource)
     end
 
-    it 'can declare several module processes' do
+    it 'Lorj.declare_process, can declare several module processes' do
       expect(Lorj.declare_process('mock', @process_path)).to be
       expect(Lorj.declare_process(:mock2, @process_path)).to be
       expect(Lorj.declare_process('mock3', @process_path)).to equal(nil)
     end
 
+    it 'become empty, if name or process_path are incorrect' do
+      expect(Lorj.declare_process(nil, @process_path)).to equal(nil)
+      expect(Lorj.declare_process('mock', nil)).to equal(nil)
+    end
+
     it 'all kept module processes in Lorj.processes not duplicated.' do
       expect(Lorj.processes.length).to eq(2)
       expect(Lorj.processes.keys).to eq(%w(mock mock2))

data/spec/22_lorj_core_spec.rb

@@ -0,0 +1,49 @@
+#!/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 'debugger'
+# require 'bundler/setup'
+
+app_path = File.dirname(__FILE__)
+
+$LOAD_PATH << File.join(app_path, '..', 'lib')
+
+require 'lorj' # Load lorj framework
+
+describe 'Lorj::Core,' do
+  context 'Using lorj-spec process, ' do
+    process_path = File.expand_path(File.join(app_path, '..', 'lorj-spec'))
+    Lorj.declare_process('mock', process_path)
+    Lorj.declare_process('mock2', process_path,
+                         :controllers_path => File.join(process_path,
+                                                        'providers_extra'))
+  end
+
+  it 'Lorj::Core.new(nil, :mock) return an error' do
+    expect { Lorj::Core.new(nil, :mock) }.to raise_error(Lorj::PrcError)
+  end
+  it 'Lorj::Core.new(nil, [{ :process_module => :mock}]) gets loaded.' do
+    expect(core = Lorj::Core.new(nil, [{ :process_module => :mock }])).to be
+    expect(core.config).to be
+    expect(core.config.layers.include?('mock')).to equal(true)
+    expect(core.config.layer_index('mock')).to equal(4)
+    expect(Lorj.data.layers.include?('mock')).to equal(true)
+    expect(Lorj.data.layer_index('mock')).to equal(3)
+  end
+end