TEST: core/main/models specs

spec/beef/core/main/models/execution_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe BeEF::Core::Models::Execution do
+  describe '.create' do
+    let(:rule) do
+      BeEF::Core::Models::Rule.create!(
+        name: 'test_rule',
+        author: 'test',
+        browser: 'FF',
+        browser_version: '1.0',
+        os: 'Windows',
+        os_version: '10',
+        modules: [].to_json,
+        execution_order: '1',
+        execution_delay: '0',
+        chain_mode: 'sequential'
+      )
+    end
+
+    it 'creates an execution with a rule_id' do
+      execution = described_class.create!(rule_id: rule.id)
+
+      expect(execution).to be_persisted
+      expect(execution.rule_id).to eq(rule.id)
+    end
+
+    it 'can access rule_id' do
+      execution = described_class.create!(rule_id: rule.id)
+
+      expect(execution.rule_id).to eq(rule.id)
+    end
+  end
+end

spec/beef/core/main/models/result_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe BeEF::Core::Models::Result do
+  describe 'associations' do
+    it 'has_one command' do
+      expect(described_class.reflect_on_association(:command)).not_to be_nil
+      expect(described_class.reflect_on_association(:command).macro).to eq(:has_one)
+    end
+
+    it 'has_one hooked_browser' do
+      expect(described_class.reflect_on_association(:hooked_browser)).not_to be_nil
+      expect(described_class.reflect_on_association(:hooked_browser).macro).to eq(:has_one)
+    end
+  end
+
+  describe '.create' do
+    let(:hooked_browser) { BeEF::Core::Models::HookedBrowser.create!(session: 'test_session', ip: '127.0.0.1') }
+    let(:command_module) { BeEF::Core::Models::CommandModule.create!(name: 'test_module', path: 'modules/test/') }
+    let(:command) { BeEF::Core::Models::Command.create!(hooked_browser_id: hooked_browser.id, command_module_id: command_module.id) }
+
+    it 'creates a result with required attributes' do
+      result = described_class.create!(
+        hooked_browser_id: hooked_browser.id,
+        command_id: command.id,
+        data: { 'test' => 'data' }.to_json,
+        status: 0,
+        date: Time.now.to_i
+      )
+
+      expect(result).to be_persisted
+      expect(result.hooked_browser_id).to eq(hooked_browser.id)
+      expect(result.command_id).to eq(command.id)
+      expect(result.status).to eq(0)
+    end
+
+    it 'can access command_id' do
+      result = described_class.create!(
+        hooked_browser_id: hooked_browser.id,
+        command_id: command.id,
+        data: {}.to_json,
+        status: 0,
+        date: Time.now.to_i
+      )
+
+      expect(result.command_id).to eq(command.id)
+    end
+  end
+end

spec/beef/core/main/models/rule_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe BeEF::Core::Models::Rule do
+  describe 'associations' do
+    it 'has_many executions' do
+      expect(described_class.reflect_on_association(:executions)).not_to be_nil
+      expect(described_class.reflect_on_association(:executions).macro).to eq(:has_many)
+    end
+  end
+
+  describe '.create' do
+    it 'creates a rule with required attributes' do
+      rule = described_class.create!(
+        name: 'test_rule',
+        author: 'test_author',
+        browser: 'FF',
+        browser_version: '1.0',
+        os: 'Windows',
+        os_version: '10',
+        modules: [].to_json,
+        execution_order: '1',
+        execution_delay: '0',
+        chain_mode: 'sequential'
+      )
+
+      expect(rule).to be_persisted
+      expect(rule.name).to eq('test_rule')
+      expect(rule.chain_mode).to eq('sequential')
+    end
+
+    it 'can have multiple executions' do
+      rule = described_class.create!(
+        name: 'test_rule',
+        author: 'test',
+        browser: 'FF',
+        browser_version: '1.0',
+        os: 'Windows',
+        os_version: '10',
+        modules: [].to_json,
+        execution_order: '1',
+        execution_delay: '0',
+        chain_mode: 'sequential'
+      )
+
+      execution1 = BeEF::Core::Models::Execution.create!(rule_id: rule.id)
+      execution2 = BeEF::Core::Models::Execution.create!(rule_id: rule.id)
+
+      expect(rule.executions.count).to eq(2)
+      expect(rule.executions).to include(execution1, execution2)
+    end
+  end
+end