cuboid 0.0.0 → 0.0.3

data/spec/cuboid/option_groups/paths_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Cuboid::OptionGroups::Paths do
+
+    before :all do
+        @created_resources = []
+    end
+
+    after :each do
+        ENV['CUBOID_LOGDIR'] = nil
+
+        (@created_resources + [paths_config_file]).each do |r|
+            FileUtils.rm_rf r
+        end
+    end
+
+    let(:paths_config_file) { "#{Cuboid::Options.paths.tmpdir}/paths-#{Process.pid}.yml" }
+
+    %w(root logs reports lib support mixins snapshots).each do |method|
+
+        describe "##{method}" do
+            it 'points to an existing directory' do
+                expect(File.exists?( subject.send method )).to be_truthy
+            end
+        end
+
+        describe "##{method}=" do
+            context 'when the path is missing a slash in the end' do
+                it 'raises error' do
+                    dir = subject.tmpdir[0..-1]
+                    subject.send "#{method}=", dir
+
+                    expect(dir).to_not end_with '/'
+                    expect(subject.send(method)).to end_with '/'
+                end
+            end
+
+            context 'when given an invalid directory' do
+                it 'raises error' do
+                    expect do
+                        subject.send "#{method}=", 'flflflfl'
+                    end.to raise_error ArgumentError
+                end
+            end
+        end
+
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
+    end
+
+    describe '#tmpdir' do
+        context 'when no tmpdir has been specified via config' do
+            it 'defaults to the OS tmpdir' do
+                expect(subject.tmpdir).to eq Cuboid.get_long_win32_filename( "#{Dir.tmpdir}/Cuboid_#{Process.pid}" )
+            end
+        end
+
+        context "when #{described_class}.config['tmpdir']" do
+            it 'returns its value' do
+                allow(described_class).to receive(:config) do
+                    {
+                        'tmpdir' => "#{Dir.tmpdir}/my/tmpdir"
+                    }
+                end
+
+                expect(subject.tmpdir).to eq("#{Dir.tmpdir}/my/tmpdir/Cuboid_#{Process.pid}")
+            end
+        end
+    end
+
+    describe '#logs' do
+        it 'returns the default location' do
+            expect(subject.logs).to eq("#{subject.root}logs/")
+        end
+
+        context 'when the CUBOID_LOGDIR environment variable' do
+            after { ENV['CUBOID_LOGDIR'] = '' }
+
+            it 'returns its value' do
+                ENV['CUBOID_LOGDIR'] = 'test'
+                expect(subject.logs).to eq('test/')
+            end
+        end
+
+        context "when #{described_class}.config['logs']" do
+            it 'returns its value' do
+                allow(described_class).to receive(:config) do
+                    {
+                        'logs' => 'logs-stuff/'
+                    }
+                end
+
+                expect(described_class.new.logs).to eq('logs-stuff/')
+            end
+        end
+    end
+
+    describe '#snapshots' do
+        it 'returns the default location' do
+            expect(subject.snapshots).to eq("#{subject.root}snapshots/")
+        end
+
+        context "when #{described_class}.config['snapshots']" do
+            it 'returns its value' do
+                allow(described_class).to receive(:config) do
+                    {
+                        'snapshots' => 'snapshots-stuff/'
+                    }
+                end
+
+                expect(described_class.new.snapshots).to eq('snapshots-stuff/')
+            end
+        end
+    end
+
+    describe '#reports' do
+        it 'returns the default location' do
+            expect(subject.reports).to eq("#{subject.root}reports/")
+        end
+
+        context "when #{described_class}.config['reports']" do
+            it 'returns its value' do
+                allow(described_class).to receive(:config) do
+                    {
+                        'reports' => 'reports-stuff/'
+                    }
+                end
+
+                expect(described_class.new.reports).to eq('reports-stuff/')
+            end
+        end
+    end
+
+    describe '.config' do
+        let(:config) { described_class.config }
+
+        it 'expands ~ to $HOME', if: !Cuboid.windows? do
+            yaml = {
+                'blah' => "~/foo-#{Process.pid}/"
+            }.to_yaml
+
+            allow(described_class).to receive(:paths_config_file) { paths_config_file }
+            IO.write( described_class.paths_config_file, yaml )
+            described_class.clear_config_cache
+
+            @created_resources << described_class.config['blah']
+
+            expect(described_class.config['blah']).to eq("#{ENV['HOME']}/foo-#{Process.pid}/")
+        end
+
+        it 'appends / to paths' do
+            dir = "#{Dir.tmpdir}/foo-#{Process.pid}"
+            yaml = {
+                'blah' => dir
+            }.to_yaml
+
+            allow(described_class).to receive(:paths_config_file) { paths_config_file }
+            IO.write( described_class.paths_config_file, yaml )
+            described_class.clear_config_cache
+
+            @created_resources << described_class.config['blah']
+
+            expect(described_class.config['blah']).to eq("#{dir}/")
+        end
+
+        it 'creates the given directories' do
+            dir = "#{Dir.tmpdir}/foo/stuff-#{Process.pid}"
+            yaml = {
+                'blah' => dir
+            }.to_yaml
+
+            allow(described_class).to receive(:paths_config_file) { paths_config_file }
+            IO.write( described_class.paths_config_file, yaml )
+            described_class.clear_config_cache
+
+            @created_resources << dir
+
+            expect(File.exist?( dir )).to be_falsey
+            described_class.config
+            expect(File.exist?( dir )).to be_truthy
+        end
+    end
+
+end

data/spec/cuboid/option_groups/report_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Cuboid::OptionGroups::Report do
+    include_examples 'option_group'
+    subject { described_class.new }
+
+    %w(path).each do |method|
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
+    end
+
+    describe '#path' do
+        context "when #{Cuboid::OptionGroups::Paths}.config['reports']" do
+            it 'returns it' do
+                allow(Cuboid::OptionGroups::Paths).to receive(:config) do
+                    {
+                        'reports' => Dir.tmpdir
+                    }
+                end
+
+                expect(subject.path).to eq(Dir.tmpdir + '/')
+            end
+        end
+    end
+
+end

data/spec/cuboid/option_groups/rpc_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Cuboid::OptionGroups::RPC do
+    include_examples 'option_group'
+    subject { described_class.new }
+
+    %w(server_socket server_external_address server_address server_port ssl_ca
+        server_ssl_private_key server_ssl_certificate client_ssl_private_key
+        client_ssl_certificate client_max_retries).each do |method|
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
+    end
+
+    describe '#to_client_options' do
+        it 'returns RPC client options' do
+            subject.connection_pool_size   = 2
+            subject.client_max_retries     = 3
+            subject.client_ssl_private_key = '2'
+            subject.client_ssl_certificate = '3'
+            subject.ssl_ca                 = '4'
+
+            expect(subject.to_client_options).to eq(
+                connection_pool_size: subject.connection_pool_size,
+                max_retries:          subject.client_max_retries,
+                ssl_ca:               subject.ssl_ca,
+                ssl_pkey:             subject.client_ssl_private_key,
+                ssl_cert:             subject.client_ssl_certificate
+            )
+        end
+    end
+
+    describe '#to_server_options' do
+        it 'returns RPC server options' do
+            subject.server_address          = 'blah'
+            subject.server_external_address = 'fsfs'
+            subject.server_port             = 2
+            subject.server_socket           = '3'
+            subject.ssl_ca                  = '4'
+            subject.server_ssl_private_key  = '4'
+            subject.server_ssl_certificate  = '4'
+
+            expect(subject.to_server_options).to eq(
+                host:             subject.server_address,
+                external_address: subject.server_external_address,
+                port:             subject.server_port,
+                socket:           subject.server_socket,
+                ssl_ca:           subject.ssl_ca,
+                ssl_pkey:         subject.server_ssl_private_key,
+                ssl_cert:         subject.server_ssl_certificate
+            )
+        end
+    end
+end

data/spec/cuboid/option_groups/snapshot_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Cuboid::OptionGroups::Snapshot do
+    include_examples 'option_group'
+    subject { described_class.new }
+
+    %w(path).each do |method|
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
+    end
+
+    describe '#path' do
+        context "when #{Cuboid::OptionGroups::Paths}.config['snapshots']" do
+            it 'returns it' do
+                allow(Cuboid::OptionGroups::Paths).to receive(:config) do
+                    {
+                        'snapshots' => Dir.tmpdir
+                    }
+                end
+
+                expect(subject.path).to eq(Dir.tmpdir + '/')
+            end
+        end
+    end
+
+end

data/spec/cuboid/option_groups/system.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Cuboid::OptionGroups::System do
+    include_examples 'option_group'
+    subject { described_class.new }
+
+    %w(max_slots).each do |method|
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
+    end
+
+end

data/spec/cuboid/options_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+describe Cuboid::Options do
+
+    subject { described_class.instance }
+    groups = described_class.group_classes.keys
+
+    it 'proxies missing class methods to instance methods' do
+        datastore = 'http://test.com/'
+        expect(subject.datastore.url).not_to eq(datastore)
+        subject.datastore.url = datastore
+        expect(subject.datastore.url).to eq(datastore)
+    end
+
+    %w(authorized_by).each do |method|
+        it { is_expected.to respond_to method }
+        it { is_expected.to respond_to "#{method}=" }
+    end
+
+    groups.each do |group|
+        describe "##{group}" do
+            it 'is an OptionGroup' do
+                expect(subject.send( group )).to be_kind_of Cuboid::OptionGroup
+                expect(subject.send( group ).class.to_s.downcase).to eq(
+                    "cuboid::optiongroups::#{group}".gsub( '_', '' )
+                )
+            end
+        end
+    end
+
+    describe '#validate' do
+        context 'when valid' do
+            it 'returns nil' do
+                expect(subject.validate).to be_empty
+            end
+        end
+
+        context 'when invalid' do
+            it 'returns errors by group'
+        end
+    end
+
+    describe '#update' do
+        it 'sets options by hash' do
+            opts = { authorized_by: 'test@test.test' }
+
+            subject.update( opts )
+            expect(subject.authorized_by).to eq(opts[:authorized_by])
+        end
+
+        context 'when key refers to an OptionGroup' do
+            it 'updates that group' do
+                opts = {
+                    datastore: {
+                        key2: 'val2'
+                    }
+                }
+
+                subject.update( opts )
+                expect(subject.datastore.to_h).to eq(opts[:datastore])
+            end
+        end
+    end
+
+    describe '#save' do
+        it 'dumps #to_h to a file' do
+            f = 'options'
+
+            subject.save( f )
+
+            raised = false
+            begin
+                File.delete( f )
+            rescue
+                raised = true
+            end
+            expect(raised).to be_falsey
+        end
+
+        it 'returns the file location'do
+            f = 'options'
+
+            f = subject.save( f )
+
+            raised = false
+            begin
+                File.delete( f )
+            rescue
+                raised = true
+            end
+            expect(raised).to be_falsey
+        end
+    end
+
+    describe '#load' do
+        it 'loads a file created by #save' do
+            f = "#{Dir.tmpdir}/options"
+
+            subject.datastore.stuff = 'test'
+            subject.save( f )
+
+            options = subject.load( f )
+            expect(options).to eq(subject)
+            expect(options.datastore.stuff).to eq('test')
+
+            raised = false
+            begin
+                File.delete( f )
+            rescue
+                raised = true
+            end
+            expect(raised).to be_falsey
+        end
+    end
+
+    describe '#to_rpc_data' do
+        let(:data) { subject.to_rpc_data }
+
+        it 'converts self to a serializable hash' do
+            expect(data).to be_kind_of Hash
+
+            expect(Cuboid::RPC::Serializer.load(
+                Cuboid::RPC::Serializer.dump( data )
+            )).to eq(data)
+        end
+
+        (groups - described_class::TO_RPC_IGNORE.to_a).each do |k|
+            k = k.to_s
+
+            it "includes the '#{k}' group" do
+                expect(data[k]).to eq(subject.send(k).to_rpc_data)
+            end
+        end
+
+        described_class::TO_RPC_IGNORE.each do |k|
+            k = k.to_s
+
+            it "does not include the '#{k}' group" do
+                expect(subject.to_rpc_data).not_to include k
+            end
+        end
+    end
+
+    describe '#to_rpc_data_without_defaults' do
+        before do
+            Cuboid::Options.reset
+        end
+
+        it 'returns RPC data that are not identical to default settings' do
+            expect(subject.dup.reset.to_rpc_data_without_defaults).to eq subject.to_rpc_data_without_defaults
+
+            subject.authorized_by = 'test@test.test'
+            subject.datastore.elements = 'forms'
+
+            expect(subject.to_rpc_data_without_defaults).to eq({
+                'authorized_by'   => 'test@test.test',
+                'datastore' => {
+                    'elements' => 'forms'
+                }
+            })
+        end
+    end
+
+    describe '#to_hash' do
+        let(:data) { subject.to_hash }
+
+        it 'converts self to a hash' do
+            subject.datastore.stuff = 'test2'
+
+            h = subject.to_hash
+            expect(h).to be_kind_of Hash
+        end
+
+        (groups - described_class::TO_HASH_IGNORE.to_a).each do |k|
+            it "includes the '#{k}' group" do
+                expect(data[k]).to eq(subject.send(k).to_hash)
+            end
+        end
+
+        described_class::TO_HASH_IGNORE.each do |k|
+            it "does not include the '#{k}' group" do
+                expect(subject.to_hash).not_to include k
+            end
+        end
+
+    end
+
+    describe '#to_h' do
+        it 'aliased to to_hash' do
+            expect(subject.to_hash).to eq(subject.to_h)
+        end
+    end
+
+    describe '#rpc_data_to_hash' do
+        it 'normalizes the given hash into #to_hash format' do
+            normalized = subject.rpc_data_to_hash(
+                'datastore' => {
+                    'request_timeout' => 90_000
+                }
+            )
+
+            expect(normalized[:datastore][:request_timeout]).to eq(90_000)
+            expect(subject.datastore.request_timeout).not_to eq(90_000)
+        end
+    end
+
+    describe '#hash_to_rpc_data' do
+        it 'normalizes the given hash into #to_rpc_data format' do
+            normalized = subject.hash_to_rpc_data(
+              datastore: { request_timeout: 90_000 }
+            )
+
+            expect(normalized['datastore']['request_timeout']).to eq(90_000)
+            expect(subject.datastore.request_timeout).not_to eq(90_000)
+        end
+    end
+
+end