cuboid 0.0.0 → 0.0.1alpha

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

data/spec/cuboid/report_spec.rb

@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+describe Cuboid::Report do
+
+    after :each do
+        File.delete( @report_file ) rescue nil
+    end
+
+    let( :report_data ) { Factory[:report_data] }
+    let( :report ) { Factory[:report] }
+    let( :report_empty ) { Factory[:report_empty] }
+
+    it "supports #{Cuboid::RPC::Serializer}" do
+        cloned = Cuboid::RPC::Serializer.deep_clone( report )
+        cloned.options.delete :input
+
+        expect(report).to eq(cloned)
+    end
+
+    describe '#to_rpc_data' do
+        let(:subject) { report }
+        let(:data) { subject.to_rpc_data }
+
+        %w(seed version).each do |attribute|
+            it "includes '#{attribute}'" do
+                expect(data[attribute]).to eq(subject.send( attribute ))
+            end
+        end
+
+        it "includes serialized 'data'" do
+            expect(data['data']).to eq Cuboid::Application.application.serializer.dump(subject.data)
+        end
+
+        it "includes 'options'" do
+            expect(data['options']).to eq(
+                Cuboid::Application.application.serializer.dump subject.options
+            )
+        end
+
+        %w(start_datetime finish_datetime).each do |attribute|
+            it "includes '#{attribute}'" do
+                expect(data[attribute]).to eq(subject.send( attribute ).to_s)
+            end
+        end
+    end
+
+    describe '.from_rpc_data' do
+        let(:subject) { report }
+
+        let(:restored) { described_class.from_rpc_data data }
+        let(:data) { Cuboid::RPC::Serializer.rpc_data( subject ) }
+
+        %w(seed version data).each do |attribute|
+            it "restores '#{attribute}'" do
+                expect(restored.send( attribute )).to eq(subject.send( attribute ))
+            end
+        end
+
+        it "restores 'options'" do
+            restored.options.delete :input
+            subject.options.delete :input
+
+            expect(restored.options).to eq(subject.options)
+        end
+
+        %w(start_datetime finish_datetime).each do |attribute|
+            it "restores '#{attribute}'" do
+                expect(restored.send( attribute )).to be_kind_of Time
+                expect(restored.send( attribute ).to_s).to eq(subject.send( attribute ).to_s)
+            end
+        end
+    end
+
+    describe '#version' do
+        it 'returns the version number' do
+            expect(report.version).to eq(Cuboid::VERSION)
+        end
+    end
+
+    describe '#seed' do
+        it 'returns the scan seed' do
+            expect(report.seed).to eq(Cuboid::Utilities.random_seed)
+        end
+    end
+
+    describe '#options' do
+        it 'returns application options'
+    end
+
+    describe '#start_datetime' do
+        it 'returns a Time object' do
+            expect(report.start_datetime).to be_kind_of Time
+        end
+        context 'when no start datetime info has been provided' do
+            it 'falls-back to Time.now' do
+                expect(report_empty.start_datetime).to be_kind_of Time
+            end
+        end
+    end
+
+    describe '#finish_datetime' do
+        it 'returns a Time object' do
+            expect(report.finish_datetime).to be_kind_of Time
+        end
+        it 'returns the start finish of the scan' do
+            expect(report.finish_datetime.to_s).to eq(
+                Factory[:report_data][:finish_datetime].to_s
+            )
+        end
+        context 'when no start datetime info has been provided' do
+            it 'falls-back to Time.now' do
+                expect(report_empty.finish_datetime).to be_kind_of Time
+            end
+        end
+    end
+
+    describe '#delta_time' do
+        it 'returns the time difference between start and finish time' do
+            expect(report.delta_time).to eq('02:46:40')
+        end
+        context 'when no #finish_datetime has been provided' do
+            it 'uses Time.now for the calculation' do
+                report_empty.start_datetime = Time.now - 2000
+                expect(report_empty.delta_time.to_s).to eq('00:33:19')
+            end
+        end
+    end
+
+    describe '.read_summary' do
+        it 'returns summary' do
+            summary = report.summary
+            summary[:application] = summary[:application].to_s
+
+            @report_file = report.save
+            expect(described_class.read_summary( @report_file )).to eq(
+                Cuboid::RPC::Serializer.load( Cuboid::RPC::Serializer.dump( summary ) ).
+                  my_symbolize_keys.tap do |s|
+                    s[:application] = ObjectSpace.const_get( s[:application].to_sym )
+                end
+            )
+        end
+    end
+
+    describe '#save' do
+        it 'dumps the object to a file' do
+            @report_file = report.save
+
+            expect(described_class.load( @report_file )).to eq(report)
+        end
+
+        context 'when given a location' do
+            context 'which is a filepath' do
+                it 'saves the object to that file' do
+                    @report_file = 'report'
+                    report.save( @report_file )
+
+                    expect(described_class.load( @report_file )).to eq(report)
+                end
+            end
+
+            context 'which is a directory' do
+                it 'saves the object under that directory' do
+                    directory = Dir.tmpdir
+                    @report_file = report.save( directory )
+
+                    expect(described_class.load( @report_file )).to eq(report)
+                end
+            end
+        end
+    end
+
+    describe '#to_crf' do
+        it 'returns the object in CRF format' do
+            @report_file = report.save
+
+            expect(IO.binread( @report_file )).to eq(report.to_crf)
+        end
+    end
+
+    describe '#from_crf' do
+        it 'loads an object from CRF data'
+    end
+
+    describe '#to_h' do
+        it 'returns the object as a hash' do
+            expect(report.to_h).to eq({
+                application:     MockApp,
+                version:         report.version,
+                status:          report.status,
+                data:            report.data,
+                seed:            report.seed,
+                options:         Cuboid::Options.hash_to_rpc_data( report.options ),
+                start_datetime:  report.start_datetime.to_s,
+                finish_datetime: report.finish_datetime.to_s,
+                delta_time:      report.delta_time,
+            })
+        end
+    end
+
+    describe '#to_hash' do
+        it 'alias of #to_h' do
+            expect(report.to_h).to eq(report.to_hash)
+        end
+    end
+
+    describe '#==' do
+        context 'when the reports are equal' do
+            it 'returns true' do
+                expect(described_class.from_crf( report.to_crf )).to eq(report)
+            end
+        end
+        context 'when the reports are not equal' do
+            it 'returns false' do
+                a = described_class.from_crf( report.to_crf )
+                a.options[:authorized_by] = 'http://stuff/'
+                expect(a).not_to eq(report)
+            end
+        end
+    end
+
+end