nucleus 0.1.0

data/spec/unit/common/oauth2_auth_client_spec.rb

@@ -0,0 +1,108 @@
+require 'spec/unit/unit_spec_helper'
+
+describe Nucleus::Adapters::OAuth2AuthClient do
+  describe 'initialization' do
+    it 'applies all values correctly' do
+      url = 'theurl'
+      check_certs = false
+      client = Nucleus::Adapters::OAuth2AuthClient.new url, check_certs
+      expect(client.instance_variable_get :@auth_url).to be url
+      expect(client.verify_ssl).to be check_certs
+    end
+  end
+
+  describe 'functionality:' do
+    subject(:client) { Nucleus::Adapters::OAuth2AuthClient.new 'http://localhost', true }
+    let!(:invalid_username) { 'invalid_username' }
+    let!(:invalid_password) { 'invalid_password' }
+    let!(:valid_username) { 'valid_username' }
+    let!(:valid_password) { 'valid_password' }
+    let!(:valid_refresh_token) { 'valid_refresh_token' }
+    let!(:invalid_refresh_token) { 'invalid_refresh_token' }
+
+    before do
+      Excon.stub({ query: { grant_type: 'password', username: valid_username, password: valid_password } },
+                 body: { access_token: 'access_token', refresh_token: valid_refresh_token,
+                         expires_in: 3600, token_type: 'bearer' }.to_json, status: 200)
+      Excon.stub({ query: { grant_type: 'password', username: invalid_username, password: invalid_password } },
+                 body: { error: 'code', error_description: 'description' }.to_json, status: 401)
+      Excon.stub({ query: { grant_type: 'refresh_token', refresh_token: valid_refresh_token } },
+                 body: { access_token: 'refreshed_access_token', expires_in: 3600,
+                         token_type: 'bearer' }.to_json, status: 200)
+      Excon.stub({ query: { grant_type: 'refresh_token', refresh_token: invalid_refresh_token } },
+                 body: { error: 'code', error_description: 'description' }.to_json, status: 401)
+    end
+
+    context 'when not authenticated' do
+      describe '#authenticate' do
+        context 'with invalid credentials' do
+          it 'raises an error when authentication failed' do
+            expect { client.authenticate(invalid_username, invalid_password) }.to raise_error(
+              Nucleus::Errors::EndpointAuthenticationError)
+          end
+        end
+
+        context 'with valid credentials' do
+          it 'returns the self instance' do
+            expect(client.authenticate(valid_username, valid_password))
+              .to be_a Nucleus::Adapters::OAuth2AuthClient
+          end
+        end
+      end
+      describe '#refresh' do
+        it 'can not be invoked' do
+          expect { client.refresh }.to raise_error(Nucleus::Errors::EndpointAuthenticationError)
+        end
+      end
+      describe '#auth_header' do
+        it 'can not be invoked' do
+          expect { client.auth_header }.to raise_error(Nucleus::Errors::EndpointAuthenticationError)
+        end
+      end
+    end
+
+    context 'when authenticated' do
+      before { client.authenticate(valid_username, valid_password) }
+      describe '#authenticate' do
+        context 'with invalid credentials' do
+          before { Excon.stub({}, body: {}, status: 400) }
+          it 'returns instance without making new auth request' do
+            expect(client.authenticate(valid_username, valid_password)).to be_a Nucleus::Adapters::OAuth2AuthClient
+          end
+        end
+        context 'with valid credentials' do
+          it 'returns instance without making new auth request' do
+            expect(client.authenticate(valid_username, valid_password)).to be_a Nucleus::Adapters::OAuth2AuthClient
+          end
+        end
+      end
+      describe '#auth_header' do
+        context 'when not expired' do
+          it 'returns an authorization header' do
+            expect(client.auth_header).to have_key('Authorization')
+            expect(client.auth_header['Authorization']).to eq 'bearer access_token'
+          end
+        end
+        context 'when expired' do
+          before do
+            client.instance_variable_set :@expiration, (Time.now - 120)
+          end
+          it 'returns an updated authorization header' do
+            expect(client.auth_header).to have_key('Authorization')
+            expect(client.auth_header['Authorization']).to eq 'bearer refreshed_access_token'
+          end
+        end
+      end
+      describe '#refresh' do
+        before { client.refresh }
+        it 'returns the self instance' do
+          expect(client.refresh).to be_a Nucleus::Adapters::OAuth2AuthClient
+        end
+        it 'makes an updated authorization header available' do
+          expect(client.auth_header).to have_key('Authorization')
+          expect(client.auth_header['Authorization']).to eq 'bearer refreshed_access_token'
+        end
+      end
+    end
+  end
+end

data/spec/unit/common/regexp_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require 'spec/unit/unit_spec_helper'
+require 'nucleus/ext/regexp'
+
+describe 'Regexp::PERFECT_URL_PATTERN' do
+  %w(
+    http://✪df.ws/123 http://userid:password@example.com:8080 http://userid:password@example.com:8080/
+    http://userid@example.com http://userid@example.com/ http://userid@example.com:8080 http://userid@example.com:8080/
+    http://userid:password@example.com http://userid:password@example.com/ http://142.42.1.1/ http://142.42.1.1:8080/
+    http://➡.ws/䨹 http://⌘.ws http://⌘.ws/ http://foo.com/blah_(wikipedia)#cite-1
+    http://foo.com/blah_(wikipedia)_blah#cite-1 http://foo.com/unicode_(✪)_in_parens
+    http://foo.com/(something)?after=parens http://☺.damowmow.com/ http://code.google.com/events/#&product=browser
+    http://j.mp ftp://foo.bar/baz http://foo.bar/?q=Test%20URL-encoded%20stuff http://مثال.إختبار
+    http://例子.测试).each do |valid_url|
+    it "matches #{valid_url}" do
+      expect(Regexp::PERFECT_URL_PATTERN =~ valid_url).to eq 0
+    end
+  end
+
+  [
+    'http://', 'http://.', 'http://..', 'http://../', 'http://?', 'http://??', 'http://??/', 'http://#', 'http://##',
+    'http://##/', 'http://foo.bar?q=Spaces should be encoded', '//', '//a', '///a', '///', 'http:///a', 'foo.com',
+    'rdar://1234', 'h://test', 'http:// shouldfail.com', ':// should fail', 'http://foo.bar/foo(bar)baz quux',
+    'ftps://foo.bar/', 'http://-error-.invalid/', 'http://a.b--c.de/', 'http://-a.b.co', 'http://a.b-.co',
+    'http://0.0.0.0', 'http://10.1.1.0', 'http://10.1.1.255', 'http://224.1.1.1', 'http://1.1.1.1.1',
+    'http://123.123.123', 'http://3628126748', 'http://.www.foo.bar/', 'http://www.foo.bar./', 'http://.www.foo.bar./',
+    'http://10.1.1.1', 'http://10.1.1.254'
+  ].each do |invalid_url|
+    it "does not match #{invalid_url}" do
+      expect(Regexp::PERFECT_URL_PATTERN =~ invalid_url).to be_nil
+    end
+  end
+end

data/spec/unit/common/request_log_formatter_spec.rb

@@ -0,0 +1,108 @@
+describe Nucleus::Logging::Formatter do
+  subject { Nucleus::Logging::Formatter.new }
+  let(:request_id) { SecureRandom.uuid }
+  let(:severity) { Logger::Severity::WARN.to_s }
+  let(:time) { Time.now }
+  let(:prog) { 'progname' }
+  let(:msg) { 'This output shall be included in the log' }
+
+  # make sure nucleus_request_id is always reset
+  before(:each) { Thread.current[:nucleus_request_id] = nil }
+
+  context 'with nucleus_request_id assigned to the current thread' do
+    before do
+      Thread.current[:nucleus_request_id] = request_id
+      @response = subject.call(severity, time, prog, msg)
+    end
+
+    it 'does include the request_id' do
+      expect(@response).to include(request_id)
+    end
+    it 'includes the program name' do
+      expect(@response).to include(prog)
+    end
+    it 'includes the actual log message' do
+      expect(@response).to include(msg)
+    end
+    it 'ends with a newline' do
+      expect(@response).to end_with("\n")
+    end
+  end
+
+  context 'nucleus_request_id unassigned' do
+    let(:dateformat) { '%Y-%m-%d' }
+    before do
+      subject.datetime_format = dateformat
+      @response = subject.call(severity, time, prog, msg)
+    end
+
+    it 'does not include the request_id' do
+      expect(@response).to_not include(request_id)
+    end
+    it 'includes the program name' do
+      expect(@response).to include(prog)
+    end
+    it 'includes the actual log message' do
+      expect(@response).to include(msg)
+    end
+    it 'ends with a newline' do
+      expect(@response).to end_with("\n")
+    end
+    it 'does included the time formatted according to the specified format' do
+      expect(@response).to include(time.strftime(dateformat))
+    end
+  end
+
+  context 'nucleus_request_id unassigned' do
+    before { @response = subject.call(severity, time, prog, msg) }
+
+    it 'does not include the request_id' do
+      expect(@response).to_not include(request_id)
+    end
+    it 'includes the program name' do
+      expect(@response).to include(prog)
+    end
+    it 'includes the actual log message' do
+      expect(@response).to include(msg)
+    end
+    it 'ends with a newline' do
+      expect(@response).to end_with("\n")
+    end
+  end
+
+  context 'with an exception as error message' do
+    let(:error) { StandardError.new(msg) }
+    before { @response = subject.call(severity, time, prog, error) }
+
+    it 'does not include the request_id' do
+      expect(@response).to_not include(request_id)
+    end
+    it 'includes the program name' do
+      expect(@response).to include(prog)
+    end
+    it 'includes the actual log message' do
+      expect(@response).to include(msg)
+    end
+    it 'ends with a newline' do
+      expect(@response).to end_with("\n")
+    end
+  end
+
+  context 'with an object as error message' do
+    let(:object) { { hashkey: 'hashvalue' } }
+    before { @response = subject.call(severity, time, prog, object) }
+
+    it 'does not include the request_id' do
+      expect(@response).to_not include(request_id)
+    end
+    it 'includes the program name' do
+      expect(@response).to include(prog)
+    end
+    it 'includes the actual log message' do
+      expect(@response).to include(object.inspect)
+    end
+    it 'ends with a newline' do
+      expect(@response).to end_with("\n")
+    end
+  end
+end

data/spec/unit/common/thread_config_accessor_spec.rb

@@ -0,0 +1,97 @@
+require 'spec/unit/unit_spec_helper'
+require 'nucleus/core/common/thread_config_accessor'
+
+class ThreadedConfig
+  thread_config_accessor :setting_a, default: 5
+end
+
+class ThreadedConfigParentA
+end
+
+class ThreadedConfigParentB
+  thread_config_accessor :setting_a, default: 13
+end
+
+class ThreadedConfigChildA < ThreadedConfigParentA
+  thread_config_accessor :setting_a, default: 11
+end
+
+class ThreadedConfigChildB < ThreadedConfigParentB
+end
+
+class ThreadedConfigReadOnly
+  thread_config_accessor_readonly :setting_a, default: 7
+end
+
+describe 'ThreadConfigAccessor' do
+  describe 'config values accessibility' do
+    it 'for config defined in base class shall be available to inheriting classes' do
+      child = ThreadedConfigChildB.new
+      expect(child.setting_a).to eql 13
+      child.setting_a = 17
+      expect(child.setting_a).to eql 17
+      expect(child.setting_a).to eql ThreadedConfigParentB.setting_a
+      ThreadedConfigParentB.setting_a = 19
+      expect(child.setting_a).to eql ThreadedConfigParentB.setting_a
+      expect(child.setting_a).to eql 19
+    end
+
+    it 'for config defined in inheriting class shall not be available to parent classes' do
+      child = ThreadedConfigChildA.new
+      expect(child.setting_a).to eql 11
+      expect { ThreadedConfigParentA.setting_a }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe 'using #thread_config_accessor' do
+    before :all do
+      # create instance
+      @config = ThreadedConfig.new
+      # assign value to the class
+      ThreadedConfig.setting_a = 1
+    end
+
+    it 'should have the same value on the class and instance' do
+      expect(@config.setting_a).to eql 1
+      expect(@config.setting_a).to eql ThreadedConfig.setting_a
+    end
+
+    it 'should have the different values in a new thread' do
+      Thread.new do
+        @config.setting_a = 2
+        expect(@config.setting_a).to eql 2
+        expect(@config.setting_a).to eql ThreadedConfig.setting_a
+      end.join
+    end
+
+    it 'should have the default values in a new thread' do
+      Thread.new do
+        expect(@config.setting_a).to eql 5
+        expect(@config.setting_a).to eql ThreadedConfig.setting_a
+      end.join
+    end
+  end
+
+  describe 'using #thread_config_accessor_readonly' do
+    before :all do
+      # create instance
+      @config = ThreadedConfigReadOnly.new
+    end
+
+    it 'should have the same value on the class and instance' do
+      expect(@config.setting_a).to eql 7
+      expect(@config.setting_a).to eql ThreadedConfigReadOnly.setting_a
+    end
+
+    it 'should keep the same default values in a new thread' do
+      Thread.new do
+        expect(@config.setting_a).to eql 7
+        expect(@config.setting_a).to eql ThreadedConfigReadOnly.setting_a
+      end.join
+    end
+
+    it 'should not allow to change the default values' do
+      Thread.new { expect { @config.setting_a = 10 }.to raise_error(NoMethodError) }.join
+    end
+  end
+end

data/spec/unit/models/endpoint_spec.rb

@@ -0,0 +1,83 @@
+require 'spec/unit/unit_spec_helper'
+
+describe Nucleus::Endpoint do
+  let(:id) { 'a123av6172812' }
+  let(:name) { 'fake endpoint name' }
+  let(:created_at) { Time.now }
+  let(:updated_at) { Time.now.to_s }
+  let(:url) { 'api.example.org' }
+  let(:app_domain) { 'apps.example.org' }
+  let(:trust) { true }
+
+  describe 'can be initialized with' do
+    context 'an empty hash and' do
+      before do
+        @endpoint = Nucleus::Endpoint.new({})
+      end
+      it 'fields are empty' do
+        expect(@endpoint.id).to be_nil
+        expect(@endpoint.name).to be_nil
+        expect(@endpoint.created_at).to be_nil
+        expect(@endpoint.updated_at).to be_nil
+        expect(@endpoint.url).to be_nil
+        expect(@endpoint.app_domain).to be_nil
+      end
+      it 'trust is set to false by default' do
+        expect(@endpoint.trust).to eql(false)
+      end
+      it 'to_s does not crash' do
+        expect { @endpoint.to_s }.to_not raise_error
+      end
+    end
+
+    context 'nil and' do
+      before do
+        @endpoint = Nucleus::Endpoint.new
+      end
+      it 'fields are empty' do
+        expect(@endpoint.id).to be_nil
+        expect(@endpoint.name).to be_nil
+        expect(@endpoint.created_at).to be_nil
+        expect(@endpoint.updated_at).to be_nil
+        expect(@endpoint.url).to be_nil
+        expect(@endpoint.app_domain).to be_nil
+      end
+      it 'trust is set to false by default' do
+        expect(@endpoint.trust).to eql(false)
+      end
+      it 'to_s does not crash' do
+        expect { @endpoint.to_s }.to_not raise_error
+      end
+    end
+
+    context 'hash properties' do
+      before do
+        @endpoint = Nucleus::Endpoint.new('id' => id, 'name' => name, 'created_at' => created_at,
+                                         'updated_at' => updated_at, 'trust' => trust, 'app_domain' => app_domain,
+                                         'url' => url)
+      end
+      it 'fields are not nil' do
+        expect(@endpoint.id).to_not be_nil
+        expect(@endpoint.name).to_not be_nil
+        expect(@endpoint.url).to_not be_nil
+        expect(@endpoint.app_domain).to_not be_nil
+        expect(@endpoint.trust).to_not be_nil
+      end
+      it 'dates and parent provider wont be applied' do
+        expect(@endpoint.created_at).to be_nil
+        expect(@endpoint.updated_at).to be_nil
+        expect(@endpoint.provider).to be_nil
+      end
+      it 'fields have the valid values assigned' do
+        expect(@endpoint.id).to eql(id)
+        expect(@endpoint.name).to eql(name)
+        expect(@endpoint.url).to eql(url)
+        expect(@endpoint.app_domain).to eql(app_domain)
+        expect(@endpoint.trust).to eql(trust)
+      end
+      it 'to_s does not crash' do
+        expect { @endpoint.to_s }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/unit/models/provider_spec.rb

@@ -0,0 +1,102 @@
+require 'spec/unit/unit_spec_helper'
+
+describe Nucleus::Provider do
+  let(:id) { '67890' }
+  let(:name) { 'fake provider name' }
+  let(:created_at) { Time.now }
+  let(:updated_at) { Time.now.to_s }
+
+  describe 'can be initialized with' do
+    context 'an empty hash and' do
+      before do
+        @provider = Nucleus::Provider.new({})
+      end
+      it 'endpoints are empty' do
+        expect(@provider.endpoints).to eql([])
+      end
+      it 'fields are empty' do
+        expect(@provider.id).to be_nil
+        expect(@provider.name).to be_nil
+        expect(@provider.created_at).to be_nil
+        expect(@provider.updated_at).to be_nil
+      end
+      it 'to_s does not crash' do
+        expect { @provider.to_s }.to_not raise_error
+      end
+    end
+
+    context 'nil and' do
+      before do
+        @provider = Nucleus::Provider.new
+      end
+      it 'providers are empty' do
+        expect(@provider.endpoints).to eql([])
+      end
+      it 'fields are empty' do
+        expect(@provider.id).to be_nil
+        expect(@provider.name).to be_nil
+        expect(@provider.created_at).to be_nil
+        expect(@provider.updated_at).to be_nil
+      end
+      it 'to_s does not crash' do
+        expect { @provider.to_s }.to_not raise_error
+      end
+    end
+
+    context 'hash properties and endpoint double' do
+      before do
+        endpoint = instance_double('Nucleus::Endpoint', name: 'endpoint name')
+        allow(endpoint).to receive(:is_a?).with(Nucleus::Endpoint).and_return(true)
+        @provider = Nucleus::Provider.new('endpoints' => [endpoint], 'id' => id, 'name' => name,
+                                         'created_at' => created_at, 'updated_at' => updated_at)
+      end
+      it 'has one endpoint' do
+        expect(@provider.endpoints).to_not eql([])
+        expect(@provider.endpoints.length).to eql(1)
+      end
+      it 'fields are not nil' do
+        expect(@provider.id).to_not be_nil
+        expect(@provider.name).to_not be_nil
+      end
+      it 'dates and parent vendor wont be applied' do
+        expect(@provider.created_at).to be_nil
+        expect(@provider.updated_at).to be_nil
+        expect(@provider.vendor).to be_nil
+      end
+      it 'fields have the valid values assigned' do
+        expect(@provider.id).to eql(id)
+        expect(@provider.name).to eql(name)
+      end
+      it 'to_s does not crash' do
+        expect { @provider.to_s }.to_not raise_error
+      end
+    end
+
+    context 'hash properties and endpoint hash' do
+      before do
+        @provider = Nucleus::Provider.new('endpoints' => [{ 'name' => 'endpoint name' }], 'id' => id, 'name' => name,
+                                     'created_at' => created_at, 'updated_at' => updated_at)
+      end
+      it 'has one endpoint' do
+        expect(@provider.endpoints).to_not eql([])
+        expect(@provider.endpoints.length).to eql(1)
+      end
+      it 'fields are not nil' do
+        expect(@provider.id).to_not be_nil
+        expect(@provider.name).to_not be_nil
+      end
+      it 'dates and parent vendor wont be applied' do
+        expect(@provider.created_at).to be_nil
+        expect(@provider.updated_at).to be_nil
+        expect(@provider.vendor).to be_nil
+      end
+      it 'fields have the valid values assigned' do
+        expect(@provider.id).to eql(id)
+        expect(@provider.name).to eql(name)
+      end
+      it 'to_s does not crash' do
+        expect { @provider.to_s }.to_not raise_error
+      end
+    end
+  end
+end