metasploit_data_models 1.0.0.pre.rails.pre.4.0b → 1.0.0

data/spec/app/models/mdm/cred_spec.rb

@@ -1,29 +1,27 @@
-require 'spec_helper'
-
-describe Mdm::Cred do
+RSpec.describe Mdm::Cred, type: :model do
   it_should_behave_like 'Metasploit::Concern.run'
 
   context "Associations" do
-    it { should have_many(:task_creds).class_name('Mdm::TaskCred').dependent(:destroy) }
-    it { should have_many(:tasks).class_name('Mdm::Task').through(:task_creds) }
-    it { should belong_to(:service).class_name('Mdm::Service') }
+    it { is_expected.to have_many(:task_creds).class_name('Mdm::TaskCred').dependent(:destroy) }
+    it { is_expected.to have_many(:tasks).class_name('Mdm::Task').through(:task_creds) }
+    it { is_expected.to belong_to(:service).class_name('Mdm::Service') }
   end
 
   context 'database' do
     context 'timestamps' do
-      it { should have_db_column(:created_at).of_type(:datetime) }
-      it { should have_db_column(:updated_at).of_type(:datetime) }
+      it { is_expected.to have_db_column(:created_at).of_type(:datetime) }
+      it { is_expected.to have_db_column(:updated_at).of_type(:datetime) }
     end
 
     context 'columns' do
-      it { should have_db_column(:service_id).of_type(:integer).with_options(:null => false) }
-      it { should have_db_column(:user).of_type(:string) }
-      it { should have_db_column(:pass).of_type(:string) }
-      it { should have_db_column(:active).of_type(:boolean).with_options(:default => true) }
-      it { should have_db_column(:proof).of_type(:string) }
-      it { should have_db_column(:ptype).of_type(:string) }
-      it { should have_db_column(:source_id).of_type(:integer) }
-      it { should have_db_column(:source_type).of_type(:string) }
+      it { is_expected.to have_db_column(:service_id).of_type(:integer).with_options(:null => false) }
+      it { is_expected.to have_db_column(:user).of_type(:string) }
+      it { is_expected.to have_db_column(:pass).of_type(:string) }
+      it { is_expected.to have_db_column(:active).of_type(:boolean).with_options(:default => true) }
+      it { is_expected.to have_db_column(:proof).of_type(:string) }
+      it { is_expected.to have_db_column(:ptype).of_type(:string) }
+      it { is_expected.to have_db_column(:source_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:source_type).of_type(:string) }
     end
   end
 
@@ -68,25 +66,23 @@ describe Mdm::Cred do
 
   context 'constants' do
     it 'should define the key_id regex' do
-      described_class::KEY_ID_REGEX.should == /([0-9a-fA-F:]{47})/
+      expect(described_class::KEY_ID_REGEX).to eq(/([0-9a-fA-F:]{47})/)
     end
 
     it 'should define ptypes to humanize' do
-      described_class::PTYPES.should == {
-          'read/write password' => 'password_rw',
-          'read-only password' => 'password_ro',
-          'SMB hash' => 'smb_hash',
-          'SSH private key' => 'ssh_key',
-          'SSH public key' => 'ssh_pubkey'
-      }
+      expect(described_class::PTYPES).to eq(
+                                             {
+                                                 'read/write password' => 'password_rw',
+                                                 'read-only password' => 'password_ro',
+                                                 'SMB hash' => 'smb_hash',
+                                                 'SSH private key' => 'ssh_key',
+                                                 'SSH public key' => 'ssh_pubkey'
+                                             }
+                                         )
     end
   end
 
   context 'methods' do
-    #
-    # lets
-    #
-
     let(:host) {
       FactoryGirl.create(
           :mdm_host,
@@ -134,55 +130,47 @@ describe Mdm::Cred do
       FactoryGirl.create(:mdm_workspace)
     }
 
-    #
-    # Callbacks
-    #
-
-    before(:all) do
-      Mdm::Workspace.any_instance.stub(:valid_ip_or_range? => true)
-    end
-
     context '#ptype_human' do
       it "should return 'read/write password' for 'password_rw'" do
         cred = FactoryGirl.build(:mdm_cred, :user => 'msfadmin', :pass => 'msfadmin', :ptype => 'password_rw')
-        cred.ptype_human.should == 'read/write password'
+        expect(cred.ptype_human).to eq('read/write password')
       end
 
       it "should return 'read-only password' for 'password_ro'" do
         cred = FactoryGirl.build(:mdm_cred, :user => 'msfadmin', :pass => 'msfadmin', :ptype => 'password_ro')
-        cred.ptype_human.should == 'read-only password'
+        expect(cred.ptype_human).to eq('read-only password')
       end
 
       it "should return 'SMB Hash' for 'smb_hash'" do
         cred = FactoryGirl.build(:mdm_cred, :user => 'msfadmin', :pass => 'msfadmin', :ptype => 'smb_hash')
-        cred.ptype_human.should == 'SMB hash'
+        expect(cred.ptype_human).to eq('SMB hash')
       end
 
       it "should return 'SSH private key' for 'ssh_key'" do
         cred = FactoryGirl.build(:mdm_cred, :user => 'msfadmin', :pass => 'msfadmin', :ptype => 'ssh_key')
-        cred.ptype_human.should == 'SSH private key'
+        expect(cred.ptype_human).to eq('SSH private key')
       end
 
       it "should return 'SSH public key' for 'ssh_pubkey'" do
         cred = FactoryGirl.build(:mdm_cred, :user => 'msfadmin', :pass => 'msfadmin', :ptype => 'ssh_pubkey')
-        cred.ptype_human.should == 'SSH public key'
+        expect(cred.ptype_human).to eq('SSH public key')
       end
     end
 
     context '#ssh_key_id' do
       it 'should return nil if not an ssh_key' do
         cred = FactoryGirl.build(:mdm_cred, :user => 'msfadmin', :pass => 'msfadmin', :ptype => 'password_rw')
-        cred.ssh_key_id.should == nil
+        expect(cred.ssh_key_id).to eq(nil)
       end
 
       it 'should return nil if proof does not contain the key id' do
         cred = FactoryGirl.build(:mdm_cred, :user => 'msfadmin', :pass => '/path/to/keyfile', :ptype => 'ssh_key', :proof => "no key here")
-        cred.ssh_key_id.should == nil
+        expect(cred.ssh_key_id).to eq(nil)
       end
 
       it 'should return the key id for an ssh_key' do
         cred = FactoryGirl.build(:mdm_cred, :user => 'msfadmin', :pass => '/path/to/keyfile', :ptype => 'ssh_key', :proof => "KEY=57:c3:11:5d:77:c5:63:90:33:2d:c5:c4:99:78:62:7a")
-        cred.ssh_key_id.should == '57:c3:11:5d:77:c5:63:90:33:2d:c5:c4:99:78:62:7a'
+        expect(cred.ssh_key_id).to eq('57:c3:11:5d:77:c5:63:90:33:2d:c5:c4:99:78:62:7a')
       end
 
     end
@@ -234,14 +222,14 @@ describe Mdm::Cred do
       it 'should behave the same for public keys as private keys' do
         pubkey2 = FactoryGirl.create(:mdm_cred, :service => service, :user => 'msfadmin', :pass => '/path/to/keyfile', :ptype => 'ssh_pubkey', :proof => "KEY=57:c3:11:5d:77:c5:63:90:33:2d:c5:c4:99:78:62:7a")
         pubkey3 = FactoryGirl.create(:mdm_cred, :service => service, :user => 'msfadmin', :pass => '/path/to/keyfile', :ptype => 'ssh_pubkey', :proof => "KEY=66:d4:22:6e:88:d6:74:A1:44:3e:d6:d5:AA:89:73:8b")
-        pubkey2.ssh_key_matches?(ssh_pubkey).should == true
-        pubkey2.ssh_key_matches?(pubkey3).should == false
+        expect(pubkey2.ssh_key_matches?(ssh_pubkey)).to eq(true)
+        expect(pubkey2.ssh_key_matches?(pubkey3)).to eq(false)
       end
 
       it 'should always return false for non ssh key creds' do
         cred2 = FactoryGirl.create(:mdm_cred, :service => other_service, :ptype => 'password', :user => 'msfadmin', :pass => 'msfadmin' )
         cred3 = FactoryGirl.create(:mdm_cred, :service => other_service, :ptype => 'password', :user => 'msfadmin', :pass => 'msfadmin' )
-        cred2.ssh_key_matches?(cred3).should == false
+        expect(cred2.ssh_key_matches?(cred3)).to eq(false)
       end
     end
 
@@ -271,11 +259,11 @@ describe Mdm::Cred do
       end
 
       it 'should return all ssh private keys with a matching id' do
-        other_ssh_key.ssh_keys.should include(ssh_key)
+        expect(other_ssh_key.ssh_keys).to include(ssh_key)
       end
 
       it 'should return all ssh public keys with a matching id' do
-        other_ssh_key.ssh_keys.should include(ssh_pubkey)
+        expect(other_ssh_key.ssh_keys).to include(ssh_pubkey)
       end
     end
 
@@ -305,11 +293,11 @@ describe Mdm::Cred do
       end
 
       it 'should return ssh private keys with matching ids' do
-        other_ssh_key.ssh_private_keys.should include(ssh_key)
+        expect(other_ssh_key.ssh_private_keys).to include(ssh_key)
       end
 
       it 'should not return ssh public keys with matching ids' do
-        other_ssh_key.ssh_private_keys.should_not include(ssh_pubkey)
+        expect(other_ssh_key.ssh_private_keys).not_to include(ssh_pubkey)
       end
     end
 
@@ -339,11 +327,11 @@ describe Mdm::Cred do
       end
 
       it 'should not return ssh private keys with matching ids' do
-        other_ssh_key.ssh_public_keys.should_not include(ssh_key)
+        expect(other_ssh_key.ssh_public_keys).not_to include(ssh_key)
       end
 
       it 'should return ssh public keys with matching ids' do
-        other_ssh_key.ssh_public_keys.should include(ssh_pubkey)
+        expect(other_ssh_key.ssh_public_keys).to include(ssh_pubkey)
       end
     end
   end
@@ -351,7 +339,7 @@ describe Mdm::Cred do
   context 'factory' do
     it 'should be valid' do
       cred = FactoryGirl.build(:mdm_cred)
-      cred.should be_valid
+      expect(cred).to be_valid
     end
   end
 

data/spec/app/models/mdm/event_spec.rb

@@ -1,27 +1,25 @@
-require 'spec_helper'
-
-describe Mdm::Event do
+RSpec.describe Mdm::Event, type: :model do
   it_should_behave_like 'Metasploit::Concern.run'
 
   context 'associations' do
-    it { should belong_to(:host).class_name('Mdm::Host') }
-    it { should belong_to(:workspace).class_name('Mdm::Workspace') }
+    it { is_expected.to belong_to(:host).class_name('Mdm::Host') }
+    it { is_expected.to belong_to(:workspace).class_name('Mdm::Workspace') }
   end
 
   context 'database' do
     context 'timestamps' do
-      it { should have_db_column(:created_at).of_type(:datetime) }
-      it { should have_db_column(:updated_at).of_type(:datetime) }
+      it { is_expected.to have_db_column(:created_at).of_type(:datetime) }
+      it { is_expected.to have_db_column(:updated_at).of_type(:datetime) }
     end
 
     context 'columns' do
-      it { should have_db_column(:workspace_id).of_type(:integer) }
-      it { should have_db_column(:host_id).of_type(:integer) }
-      it { should have_db_column(:name).of_type(:string) }
-      it { should have_db_column(:critical).of_type(:boolean) }
-      it { should have_db_column(:seen).of_type(:boolean) }
-      it { should have_db_column(:username).of_type(:string) }
-      it { should have_db_column(:info).of_type(:text) }
+      it { is_expected.to have_db_column(:workspace_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:host_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:name).of_type(:string) }
+      it { is_expected.to have_db_column(:critical).of_type(:boolean) }
+      it { is_expected.to have_db_column(:seen).of_type(:boolean) }
+      it { is_expected.to have_db_column(:username).of_type(:string) }
+      it { is_expected.to have_db_column(:info).of_type(:text) }
     end
   end
 
@@ -43,23 +41,23 @@ describe Mdm::Event do
       let(:workspace) {FactoryGirl.create(:mdm_workspace)}
       let(:flagged_event) { FactoryGirl.create(:mdm_event, :workspace => workspace, :name => 'flagme', :critical => true, :seen => false) }
       let(:non_critical_event) { FactoryGirl.create(:mdm_event, :workspace => workspace, :name => 'dontflagmebro', :critical => false, :seen => false) }
- 
+
       before(:each) do
         flagged_event
         non_critical_event
       end
- 
+
       it 'should included critical unseen events' do
-        Mdm::Event.flagged.should eq [flagged_event]
+        expect(Mdm::Event.flagged).to eq [flagged_event]
       end
       it 'should exclude non-critical events' do
-        Mdm::Event.flagged.should_not include(non_critical_event)
+        expect(Mdm::Event.flagged).not_to include(non_critical_event)
       end
 
       it 'should exclude critical seen events' do
         flagged_event.seen = true
         flagged_event.save
-        Mdm::Event.flagged.should_not include(flagged_event)
+        expect(Mdm::Event.flagged).not_to include(flagged_event)
       end
     end
 
@@ -68,8 +66,8 @@ describe Mdm::Event do
         flagged_event = FactoryGirl.create(:mdm_event, :name => 'module_run')
         non_critical_event = FactoryGirl.create(:mdm_event, :name => 'dontflagmebro')
         flagged_set = Mdm::Event.module_run
-        flagged_set.should include(flagged_event)
-        flagged_set.should_not include(non_critical_event)
+        expect(flagged_set).to include(flagged_event)
+        expect(flagged_set).not_to include(non_critical_event)
       end
     end
   end
@@ -77,15 +75,15 @@ describe Mdm::Event do
   context 'validations' do
     it 'should require name' do
       unnamed_event = FactoryGirl.build(:mdm_event, :name => nil)
-      unnamed_event.should_not be_valid
-      unnamed_event.errors[:name].should include("can't be blank")
+      expect(unnamed_event).not_to be_valid
+      expect(unnamed_event.errors[:name]).to include("can't be blank")
     end
   end
 
   context 'factory' do
     it 'should be valid' do
       event = FactoryGirl.build(:mdm_event)
-      event.should be_valid
+      expect(event).to be_valid
     end
   end
 

data/spec/app/models/mdm/exploit_attempt_spec.rb

@@ -1,31 +1,29 @@
-require 'spec_helper'
-
-describe Mdm::ExploitAttempt do
+RSpec.describe Mdm::ExploitAttempt, type: :model do
   it_should_behave_like 'Metasploit::Concern.run'
 
   context 'associations' do
-    it { should belong_to(:host).class_name('Mdm::Host') }
+    it { is_expected.to belong_to(:host).class_name('Mdm::Host') }
   end
 
   context 'database' do
 
     context 'timestamps'do
-      it { should have_db_column(:attempted_at).of_type(:datetime) }
+      it { is_expected.to have_db_column(:attempted_at).of_type(:datetime) }
     end
 
     context 'columns' do
-      it { should have_db_column(:host_id).of_type(:integer) }
-      it { should have_db_column(:service_id).of_type(:integer) }
-      it { should have_db_column(:vuln_id).of_type(:integer) }
-      it { should have_db_column(:exploited).of_type(:boolean) }
-      it { should have_db_column(:fail_reason).of_type(:string) }
-      it { should have_db_column(:username).of_type(:string) }
-      it { should have_db_column(:module).of_type(:text) }
-      it { should have_db_column(:session_id).of_type(:integer) }
-      it { should have_db_column(:loot_id).of_type(:integer) }
-      it { should have_db_column(:port).of_type(:integer) }
-      it { should have_db_column(:proto).of_type(:string) }
-      it { should have_db_column(:fail_detail).of_type(:text) }
+      it { is_expected.to have_db_column(:host_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:service_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:vuln_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:exploited).of_type(:boolean) }
+      it { is_expected.to have_db_column(:fail_reason).of_type(:string) }
+      it { is_expected.to have_db_column(:username).of_type(:string) }
+      it { is_expected.to have_db_column(:module).of_type(:text) }
+      it { is_expected.to have_db_column(:session_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:loot_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:port).of_type(:integer) }
+      it { is_expected.to have_db_column(:proto).of_type(:string) }
+      it { is_expected.to have_db_column(:fail_detail).of_type(:text) }
     end
   end
 
@@ -45,17 +43,17 @@ describe Mdm::ExploitAttempt do
   context 'validations' do
     it 'should only be valid with a host_id' do
       orphaned_attempt = FactoryGirl.build(:mdm_exploit_attempt, :host => nil)
-      orphaned_attempt.should_not be_valid
-      orphaned_attempt.errors[:host_id].should include("can't be blank")
+      expect(orphaned_attempt).not_to be_valid
+      expect(orphaned_attempt.errors[:host_id]).to include("can't be blank")
       propper_attempt = FactoryGirl.build(:mdm_exploit_attempt)
-      propper_attempt.should be_valid
+      expect(propper_attempt).to be_valid
     end
   end
 
   context 'factory' do
     it 'should be valid' do
       exploit_attempt = FactoryGirl.build(:mdm_exploit_attempt)
-      exploit_attempt.should be_valid
+      expect(exploit_attempt).to be_valid
     end
   end
 end

data/spec/app/models/mdm/exploited_host_spec.rb

@@ -1,26 +1,24 @@
-require 'spec_helper'
-
-describe Mdm::ExploitedHost do
+RSpec.describe Mdm::ExploitedHost, type: :model do
   it_should_behave_like 'Metasploit::Concern.run'
 
   context 'associations' do
-    it { should belong_to(:host).class_name('Mdm::Host') }
-    it { should belong_to(:service).class_name('Mdm::Service') }
+    it { is_expected.to belong_to(:host).class_name('Mdm::Host') }
+    it { is_expected.to belong_to(:service).class_name('Mdm::Service') }
   end
 
   context 'database' do
 
     context 'timestamps'do
-      it { should have_db_column(:created_at).of_type(:datetime).with_options(:null => false) }
-      it { should have_db_column(:updated_at).of_type(:datetime).with_options(:null => false) }
+      it { is_expected.to have_db_column(:created_at).of_type(:datetime).with_options(:null => false) }
+      it { is_expected.to have_db_column(:updated_at).of_type(:datetime).with_options(:null => false) }
     end
 
     context 'columns' do
-      it { should have_db_column(:host_id).of_type(:integer).with_options(:null => false) }
-      it { should have_db_column(:service_id).of_type(:integer) }
-      it { should have_db_column(:name).of_type(:string) }
-      it { should have_db_column(:session_uuid).of_type(:string) }
-      it { should have_db_column(:payload).of_type(:string) }
+      it { is_expected.to have_db_column(:host_id).of_type(:integer).with_options(:null => false) }
+      it { is_expected.to have_db_column(:service_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:name).of_type(:string) }
+      it { is_expected.to have_db_column(:session_uuid).of_type(:string) }
+      it { is_expected.to have_db_column(:payload).of_type(:string) }
     end
   end
 
@@ -39,7 +37,7 @@ describe Mdm::ExploitedHost do
   context 'factory' do
     it 'should be valid' do
       exploited_host = FactoryGirl.build(:mdm_exploited_host)
-      exploited_host.should be_valid
+      expect(exploited_host).to be_valid
     end
   end
 

data/spec/app/models/mdm/host_detail_spec.rb

@@ -1,37 +1,35 @@
-require 'spec_helper'
-
-describe Mdm::HostDetail do
+RSpec.describe Mdm::HostDetail, type: :model do
   it_should_behave_like 'Metasploit::Concern.run'
 
   context 'associations' do
-    it { should belong_to(:host).class_name('Mdm::Host') }
+    it { is_expected.to belong_to(:host).class_name('Mdm::Host') }
   end
 
   context 'database' do
-    it { should have_db_column(:host_id).of_type(:integer) }
-    it { should have_db_column(:nx_console_id).of_type(:integer) }
-    it { should have_db_column(:nx_device_id).of_type(:integer) }
-    it { should have_db_column(:src).of_type(:string) }
-    it { should have_db_column(:nx_site_name).of_type(:string) }
-    it { should have_db_column(:nx_site_importance).of_type(:string) }
-    it { should have_db_column(:src).of_type(:string) }
-    it { should have_db_column(:nx_site_name).of_type(:string) }
-    it { should have_db_column(:nx_scan_template).of_type(:string) }
-    it { should have_db_column(:nx_risk_score).of_type(:float) }
+    it { is_expected.to have_db_column(:host_id).of_type(:integer) }
+    it { is_expected.to have_db_column(:nx_console_id).of_type(:integer) }
+    it { is_expected.to have_db_column(:nx_device_id).of_type(:integer) }
+    it { is_expected.to have_db_column(:src).of_type(:string) }
+    it { is_expected.to have_db_column(:nx_site_name).of_type(:string) }
+    it { is_expected.to have_db_column(:nx_site_importance).of_type(:string) }
+    it { is_expected.to have_db_column(:src).of_type(:string) }
+    it { is_expected.to have_db_column(:nx_site_name).of_type(:string) }
+    it { is_expected.to have_db_column(:nx_scan_template).of_type(:string) }
+    it { is_expected.to have_db_column(:nx_risk_score).of_type(:float) }
   end
 
   context 'validations' do
     it 'should only be valid with a host_id' do
       orphan_detail = FactoryGirl.build(:mdm_host_detail, :host => nil)
-      orphan_detail.should_not be_valid
-      orphan_detail.errors[:host_id].should include("can't be blank")
+      expect(orphan_detail).not_to be_valid
+      expect(orphan_detail.errors[:host_id]).to include("can't be blank")
     end
   end
 
   context 'factory' do
     it 'should be valid' do
       host_detail = FactoryGirl.build(:mdm_host_detail)
-      host_detail.should be_valid
+      expect(host_detail).to be_valid
     end
   end