metasploit-model 0.24.1-java

data/spec/lib/metasploit/model/search_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search do
+  subject(:base_instance) do
+    base_class.new
+  end
+
+  let(:base_class) do
+    Class.new
+  end
+
+  before(:each) do
+    # class needs to be named or search_i18n_scope will error
+    stub_const('Searched', base_class)
+
+    base_class.send(:include, described_class)
+  end
+
+  it { should be_a Metasploit::Model::Search::Association }
+  it { should be_a Metasploit::Model::Search::Attribute }
+  it { should be_a Metasploit::Model::Search::With }
+
+  context 'search_operator_by_name' do
+    subject(:search_operator_by_name) do
+      base_class.search_operator_by_name
+    end
+
+    context 'with search attribute' do
+      let(:attribute) do
+        :searched_attribute
+      end
+
+      before(:each) do
+        base_class.search_attribute attribute, :type => :string
+      end
+
+      context 'operator' do
+        subject(:operator) do
+          search_operator_by_name[attribute]
+        end
+
+        context 'name' do
+          subject(:name) do
+            operator.name
+          end
+
+          it 'should be same as the attribute' do
+            name.should == attribute
+          end
+        end
+      end
+    end
+
+    context 'with search association' do
+      let(:association) do
+        :associated_things
+      end
+
+      before(:each) do
+        base_class.search_association association
+      end
+
+      context 'with reflect_on_association' do
+        before(:each) do
+          base_class.send(:include, Metasploit::Model::Association)
+        end
+
+        context 'with association' do
+          let(:associated_attribute) do
+            :association_name
+          end
+
+          let(:association_class) do
+            Class.new
+          end
+
+          let(:class_name) do
+            'AssociatedThing'
+          end
+
+          before(:each) do
+            stub_const(class_name, association_class)
+
+            # Include after stub so search_i18n_scope can use Class#name without error
+            association_class.send(:include, Metasploit::Model::Search)
+            association_class.search_attribute associated_attribute, :type => :string
+
+            base_class.association association, :class_name => class_name
+          end
+
+          context 'operator' do
+            subject(:operator) do
+              search_operator_by_name[expected_name]
+            end
+
+            let(:expected_name) do
+              "#{association}.#{associated_attribute}".to_sym
+            end
+
+            it { should be_a Metasploit::Model::Search::Operator::Association }
+
+            context 'association' do
+              subject(:operator_association) do
+                operator.association
+              end
+
+              it 'should be the registered association' do
+                operator_association.should == association
+              end
+            end
+
+            context 'attribute_operator' do
+              subject(:indirect_attribute_operator) do
+                operator.attribute_operator
+              end
+
+              let(:direct_attribute_operator) do
+                association_class.search_operator_by_name.values.first
+              end
+
+              it 'should be operator from associated class' do
+                indirect_attribute_operator.should == direct_attribute_operator
+              end
+            end
+
+            context 'klass' do
+              subject(:klass) do
+                operator.klass
+              end
+
+              it 'should be class that called search_operator_by_name' do
+                klass.should == base_class
+              end
+            end
+          end
+        end
+
+        context 'without association' do
+          it 'should raise Metasploit::Model::Association::Error' do
+            expect {
+              search_operator_by_name
+            }.to raise_error(Metasploit::Model::Association::Error)
+          end
+
+          context 'error' do
+            let(:error) do
+              begin
+                search_operator_by_name
+              rescue Metasploit::Model::Association::Error => error
+                error
+              end
+            end
+
+            context 'model' do
+              subject(:model) do
+                error.model
+              end
+
+              it 'should be class on which search_operator_by_name was called' do
+                model.should == base_class
+              end
+            end
+
+            context 'name' do
+              subject(:name) do
+                error.name
+              end
+
+              it 'should be association name' do
+                name.should == association
+              end
+            end
+          end
+        end
+      end
+
+      context 'without reflect_on_association' do
+        it 'should raise ArgumentError' do
+          expect {
+            search_operator_by_name
+          }.to raise_error(
+                   NameError,
+                   "#{base_class} does not respond to reflect_on_association.  " \
+                     "It can be added to ActiveModels by including Metasploit::Model::Association into the class."
+               )
+        end
+      end
+    end
+
+    context 'with search with' do
+      let(:name) do
+        :searched_with
+      end
+
+      let(:operator) do
+        double(
+            'Operator',
+            :name => name,
+            :valid! => nil
+        )
+      end
+
+      let(:operator_class) do
+        double('Operator Class', :new => operator)
+      end
+
+      before(:each) do
+        base_class.search_with operator_class
+      end
+
+      context 'operator' do
+        subject(:named_operator) do
+          search_operator_by_name[name]
+        end
+
+        it 'should be in search_operator_by_name' do
+          named_operator.should == operator
+        end
+      end
+    end
+
+    context 'without search attribute' do
+      context 'without search association' do
+        context 'without search with' do
+          it { should be_empty }
+        end
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/spec/error_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Spec::Error do
+  it { should be_a StandardError }
+end

data/spec/lib/metasploit/model/spec/i18n_exception_handler_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Spec::I18nExceptionHandler do
+  subject(:i18n_exception_handler) do
+    described_class.new
+  end
+
+  context '#call' do
+    subject(:call) do
+      i18n_exception_handler.call(exception, locale, key, options)
+    end
+
+    let(:exception) do
+      I18n::MissingTranslation.new(locale, key, options)
+    end
+
+    let(:locale) do
+      :en
+    end
+
+    let(:key) do
+      :'missing.key'
+    end
+
+    let(:options) do
+      {}
+    end
+
+    it 'should raise exception.to_exception' do
+      converted_exception = exception.to_exception
+
+      expect {
+        call
+      }.to raise_error(converted_exception.class) do |actual_exception|
+        actual_exception.class == converted_exception.class
+        actual_exception.key.should == converted_exception.key
+        actual_exception.locale.should == converted_exception.locale
+        actual_exception.options.should == converted_exception.options
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/spec/pathname_collision_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Spec::PathnameCollision do
+  let(:pathname) do
+    Metasploit::Model::Spec.temporary_pathname.join('pathname')
+  end
+
+  subject(:pathname_collision) do
+    described_class.new(pathname)
+  end
+
+  it { should be_a Metasploit::Model::Spec::Error }
+
+  context 'check!' do
+    subject(:check!) do
+      described_class.check!(pathname)
+    end
+
+    context 'with existing Pathname' do
+      before(:each) do
+        pathname.mkpath
+      end
+
+      it 'should raise Metasploit::Model::Spec::PathnameCollision' do
+        expect {
+          check!
+        }.to raise_error(described_class)
+      end
+    end
+
+    context 'without existing Pathname' do
+      it 'should not raise error' do
+        expect {
+          check!
+        }.to_not raise_error
+      end
+    end
+  end
+
+  context '#initialize' do
+    context '#message' do
+      subject(:message) do
+        pathname_collision.message
+      end
+
+      it 'should include pathname' do
+        message.should include("#{pathname} already exists.")
+      end
+
+      it 'should include potential cause' do
+        message.should include('Metasploit::Model::Spec.remove_temporary_pathname was not called after the previous spec.')
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/spec_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Spec do
+  before(:each) do
+    @before_temporary_pathname = described_class.send(:remove_instance_variable, :@temporary_pathname)
+  end
+
+  after(:each) do
+    described_class.instance_variable_set(:@temporary_pathname, @before_temporary_pathname)
+  end
+
+  context 'remove_temporary_pathname' do
+    subject(:remove_temporary_pathname) do
+      described_class.remove_temporary_pathname
+    end
+
+    let(:pathname) do
+      Metasploit::Model.root.join('spec', 'pathname')
+    end
+
+    context 'with temporary_pathname set' do
+      before(:each) do
+        described_class.temporary_pathname = pathname
+      end
+
+      context 'that exists' do
+        before(:each) do
+          pathname.mkpath
+
+          child_pathname = pathname.join('child')
+
+          child_pathname.open('wb') do |f|
+            f.puts 'Child File'
+          end
+        end
+
+        it 'should remove file tree' do
+          pathname.exist?.should be_true
+
+          remove_temporary_pathname
+
+          pathname.exist?.should be_false
+        end
+      end
+
+      context 'that does not exist' do
+        it 'should not raise an error' do
+          expect {
+            remove_temporary_pathname
+          }.to_not raise_error
+        end
+      end
+    end
+
+    context 'without temporary_pathname set' do
+      it 'should not error' do
+        expect {
+          remove_temporary_pathname
+        }.to_not raise_error
+      end
+    end
+  end
+
+  context 'temporary_pathname' do
+    subject(:temporary_pathname) do
+      described_class.temporary_pathname
+    end
+
+    context 'with @temporary_pathname defined' do
+      let(:pathname) do
+        Metasploit::Model.root.join('spec', 'pathname')
+      end
+
+      before(:each) do
+        described_class.temporary_pathname = pathname
+      end
+
+      it 'should not raise error' do
+        expect {
+          temporary_pathname
+        }.to_not raise_error
+      end
+
+      it 'should return set pathname' do
+        temporary_pathname.should == pathname
+      end
+    end
+
+    context 'without @temporary_pathname defined' do
+      it 'should raise Metasploit::Model::Spec::Error' do
+        expect {
+          temporary_pathname
+        }.to raise_error(
+                 Metasploit::Model::Spec::Error,
+                 'Metasploit::Model::Spec.temporary_pathname not set prior to use'
+             )
+      end
+    end
+  end
+
+  context 'temporary_pathname=' do
+    let(:temporary_pathname) do
+      Metasploit::Model.root.join('spec', 'temporary_pathname')
+    end
+
+    it 'should set @temporary_pathname' do
+      expect {
+        described_class.temporary_pathname = temporary_pathname
+      }.to change {
+        described_class.instance_variable_get(:@temporary_pathname)
+      }.to(temporary_pathname)
+    end
+  end
+end