ronin-exploits 1.0.0.beta2 → 1.0.0

data/spec/mixins/has_targets_spec.rb

@@ -1,434 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/mixins/has_targets'
-require 'ronin/exploits/exploit'
-
-describe Ronin::Exploits::Mixins::HasTargets do
-  module TestHasTargets
-    class WithNoTargets < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Mixins::HasTargets
-    end
-
-    class WithOneTarget < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Mixins::HasTargets
-
-      target arch: :x86_64, os: :linux, foo: 42
-    end
-
-    class InheritesTargets < WithOneTarget
-    end
-
-    class InheritesAndAddsTargets < WithOneTarget
-      target arch: :arm, os: :linux, foo: 1337
-    end
-
-    class WitthMultipleTargets < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Mixins::HasTargets
-
-      target arch: :x86_64, os: :linux, foo: 42
-      target arch: :arm,    os: :linux, foo: 1337
-    end
-  end
-
-  describe ".targets" do
-    subject { test_class }
-
-    context "with there are no targets" do
-      let(:test_class) { TestHasTargets::WithNoTargets }
-
-      it "must default to []" do
-        expect(subject.targets).to eq([])
-      end
-    end
-
-    context "with at least one target" do
-      let(:test_class) { TestHasTargets::WithOneTarget }
-
-      it "must contain Ronin::Exploits::Target objects" do
-        expect(subject.targets).to all(be_kind_of(Ronin::Exploits::Target))
-      end
-    end
-
-    context "when the super-class defines it's own targets" do
-      let(:test_class)  { TestHasTargets::InheritesTargets }
-      let(:super_class) { test_class.superclass }
-
-      it "must inherit the targets from the super-class" do
-        expect(subject.targets).to eq(super_class.targets)
-      end
-
-      context "but the sub-class defines additional targets" do
-        let(:test_class) { TestHasTargets::InheritesAndAddsTargets }
-
-        it "must combine the sub-classes targets with the super-classes" do
-          expect(subject.targets).to include(*super_class.targets)
-        end
-
-        it "must not modify the superclasses targets" do
-          expect(super_class.targets).to_not contain_exactly(*subject.targets)
-        end
-      end
-    end
-  end
-
-  describe ".target" do
-    context "when given keyword arguments" do
-      module TestHasTargets
-        class ExploitWithTargetWithKeywordArgs < Ronin::Exploits::Exploit
-          include Ronin::Exploits::Mixins::HasTargets
-
-          target arch: :x86_64, os: :linux, foo: 42
-        end
-      end
-
-      subject { TestHasTargets::ExploitWithTargetWithKeywordArgs }
-      let(:target) { subject.targets.last }
-
-      it "must initialize a new Ronin::Exploits::Target and add it to .targets" do
-        expect(target).to be_kind_of(Ronin::Exploits::Target)
-        expect(target.arch).to eq(:x86_64)
-        expect(target.os).to   eq(:linux)
-        expect(target.foo).to  eq(42)
-      end
-
-      context "and when given a block" do
-        module TestHasTargets
-          class ExploitWithTargetWithKeywordArgsAndBlock < Ronin::Exploits::Exploit
-            include Ronin::Exploits::Mixins::HasTargets
-
-            target arch: :x86_64, os: :linux do |t|
-              t.foo = 42
-            end
-          end
-        end
-
-        subject { TestHasTargets::ExploitWithTargetWithKeywordArgsAndBlock }
-        let(:target) { subject.targets.last }
-
-        it "must initialize a new Ronin::Exploits::Target and add it to .targets" do
-          expect(target).to be_kind_of(Ronin::Exploits::Target)
-          expect(target.arch).to eq(:x86_64)
-          expect(target.os).to   eq(:linux)
-          expect(target.foo).to  eq(42)
-        end
-      end
-    end
-  end
-
-  module TestHasTargets
-    class ExampleExploit < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Mixins::HasTargets
-
-      target arch: :x86_64,
-             os: :linux,
-             os_version: '5.18.1',
-             software: 'Apache',
-             version: '2.4.53',
-             foo: 1
-
-      target arch: :arm,
-             os: :macos,
-             os_version: '10.13',
-             software: 'nginx',
-             version: '1.22.0',
-             foo: 2
-    end
-  end
-
-  let(:test_class) { TestHasTargets::ExampleExploit }
-  subject { test_class.new }
-
-  describe "#initialize" do
-    context "when not given the target: keyword argument" do
-      it "must default #target to nil" do
-        expect(subject.target).to be(nil)
-      end
-    end
-
-    context "when given the target: keyword argument" do
-      context "and it's a Hash" do
-        subject do
-          test_class.new(target: {os: :macos, os_version: '10.13'})
-        end
-
-        it "must select the matching target from .targets and set #target" do
-          expect(subject.target).to be(test_class.targets[1])
-        end
-      end
-
-      context "and it's an Integer" do
-        let(:target_index) { 1 }
-
-        subject { test_class.new(target: target_index) }
-
-        it "must select the target from .targets at the given index" do
-          expect(subject.target).to be(test_class.targets[target_index])
-        end
-      end
-    end
-  end
-
-  describe "#target=" do
-    context "when given a Target object" do
-      let(:target ) { Ronin::Exploits::Target.new }
-
-      before { subject.target = target }
-
-      it "must set #target to nil" do
-        expect(subject.target).to be(target)
-      end
-    end
-
-    context "when given an Integer" do
-      let(:target_index) { 1 }
-
-      before { subject.target = target_index }
-
-      it "must set the target from .targets at the given index" do
-        expect(subject.target).to be(test_class.targets[target_index])
-      end
-
-      context "but the index is out of bounds" do
-        let(:index) { 9000 }
-
-        it do
-          expect {
-            subject.target = index
-          }.to raise_error(described_class::NoMatchingTarget,"target index is out of bounds: #{index.inspect}")
-        end
-      end
-    end
-
-    context "when given a Target object" do
-      before do
-        subject.target = Ronin::Exploits::Target.new
-        subject.target = nil
-      end
-
-      it "must set #target to nil" do
-        expect(subject.target).to be(nil)
-      end
-    end
-  end
-
-  describe "#perform_validate" do
-    context "when #target is set" do
-      before { subject.target = subject.class.targets[0] }
-
-      it "must not raise NoTargetSelected" do
-        expect {
-          subject.perform_validate
-        }.to_not raise_error
-      end
-
-      it "must call #validate_params first" do
-        expect(subject).to receive(:validate_params)
-
-        subject.perform_validate
-      end
-    end
-
-    context "when #target is not set" do
-      it do
-        expect {
-          subject.perform_validate
-        }.to raise_error(described_class::NoTargetSelected,"no target was selected")
-      end
-    end
-  end
-
-  describe "#select_target" do
-    context "when given no keyword arguments" do
-      subject do
-        test_class.new(target: {os: :macos, os_version: '10.13'})
-      end
-
-      it "must return the first target in .targets and set #target" do
-        subject.select_target
-
-        expect(subject.target).to be(test_class.targets.first)
-      end
-    end
-
-    context "when given the arch: keyword argument" do
-      let(:arch) { :arm }
-
-      it "must find the target in .targets with the matching #arch" do
-        subject.select_target(arch: arch)
-
-        expect(subject.target.arch).to eq(arch)
-      end
-    end
-
-    context "when given the os: keyword argument" do
-      let(:os) { :macos }
-
-      it "must find the target in .targets with the matching #os" do
-        subject.select_target(os: os)
-
-        expect(subject.target.os).to eq(os)
-      end
-    end
-
-    context "when given the os_version: keyword argument" do
-      let(:os_version) { '10.13' }
-
-      it "must find the target in .targets with the matching #os_version" do
-        subject.select_target(os_version: os_version)
-
-        expect(subject.target.os_version).to eq(os_version)
-      end
-    end
-
-    context "when given the software: keyword argument" do
-      let(:software) { 'nginx' }
-
-      it "must find the target in .targets with the matching #software" do
-        subject.select_target(software: software)
-
-        expect(subject.target.software).to eq(software)
-      end
-    end
-
-    context "when given the version: keyword argument" do
-      let(:version) { '1.22.0' }
-
-      it "must find the target in .targets with the matching #version" do
-        subject.select_target(version: version)
-
-        expect(subject.target.version).to eq(version)
-      end
-    end
-
-    context "when given multiple keyword arguments" do
-      let(:arch)       { :arm     }
-      let(:os)         { :macos   }
-      let(:os_version) { '10.13'  }
-      let(:software)   { 'nginx'  }
-      let(:version)    { '1.22.0' }
-
-      it "must find the target in .targets which matches all given values" do
-        subject.select_target(
-          arch:             arch,
-          os:               os,
-          os_version:       os_version,
-          software:         software,
-          version: version
-        )
-
-        expect(subject.target.arch).to             eq(arch)
-        expect(subject.target.os).to               eq(os)
-        expect(subject.target.os_version).to       eq(os_version)
-        expect(subject.target.software).to         eq(software)
-        expect(subject.target.version).to eq(version)
-      end
-    end
-
-    context "but when no matching target could be found in .targets" do
-      it do
-        expect {
-          subject.select_target(arch: :foo)
-        }.to raise_error(described_class::NoMatchingTarget,"could not find any matching targets")
-      end
-    end
-  end
-
-  describe "#arch" do
-    context "when a target has been set" do
-      subject do
-        test_class.new(target: {arch: :arm})
-      end
-
-      it "must return the #target's #arch" do
-        expect(subject.arch).to eq(subject.target.arch)
-      end
-    end
-
-    context "when no target has been set" do
-      subject { test_class.new }
-
-      it "must return nil" do
-        expect(subject.arch).to be(nil)
-      end
-    end
-  end
-
-  describe "#os" do
-    context "when a target has been set" do
-      subject do
-        test_class.new(target: {os: :macos})
-      end
-
-      it "must return the #target's #os" do
-        expect(subject.os).to eq(subject.target.os)
-      end
-    end
-
-    context "when no target has been set" do
-      subject { test_class.new }
-
-      it "must return nil" do
-        expect(subject.os).to be(nil)
-      end
-    end
-  end
-
-  describe "#os_version" do
-    context "when a target has been set" do
-      subject do
-        test_class.new(target: {os_version: '10.13'})
-      end
-
-      it "must return the #target's #os_version" do
-        expect(subject.os_version).to eq(subject.target.os_version)
-      end
-    end
-
-    context "when no target has been set" do
-      subject { test_class.new }
-
-      it "must return nil" do
-        expect(subject.os_version).to be(nil)
-      end
-    end
-  end
-
-  describe "#software" do
-    context "when a target has been set" do
-      subject do
-        test_class.new(target: {software: 'nginx'})
-      end
-
-      it "must return the #target's #software" do
-        expect(subject.software).to eq(subject.target.software)
-      end
-    end
-
-    context "when no target has been set" do
-      subject { test_class.new }
-
-      it "must return nil" do
-        expect(subject.software).to be(nil)
-      end
-    end
-  end
-
-  describe "#version" do
-    context "when a target has been set" do
-      subject do
-        test_class.new(target: {version: '1.22.0'})
-      end
-
-      it "must return the #target's #version" do
-        expect(subject.version).to eq(subject.target.version)
-      end
-    end
-
-    context "when no target has been set" do
-      subject { test_class.new }
-
-      it "must return nil" do
-        expect(subject.version).to be(nil)
-      end
-    end
-  end
-end