ronin 1.5.1 → 2.0.0.beta1

data/spec/script/deployable_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-require 'script/classes/deployable_class'
-
-describe Script::Deployable do
-  subject do
-    obj = DeployableClass.new
-    obj.instance_eval do
-      test do
-        unless @var > 0
-          raise "script failed verification"
-        end
-      end
-    end
-
-    obj
-  end
-
-  it "should include Testable" do
-    expect(subject.class.included_modules).to include(Script::Testable)
-  end
-
-  it "should not be deployed by default" do
-    expect(subject).not_to be_deployed
-  end
-
-  describe "#deploy!" do
-    it "should test! the script before deploying it" do
-      subject.var = -1
-
-      expect {
-        subject.deploy!
-      }.to raise_error(RuntimeError)
-    end
-
-    it "should mark the script deployed" do
-      subject.deploy!
-
-      expect(subject).to be_deployed
-    end
-
-    it "should not mark the script as evacuated" do
-      subject.deploy!
-
-      expect(subject).not_to be_evacuated
-    end
-  end
-
-  describe "#evacuate!" do
-    it "should mark the script as evacuated" do
-      subject.evacuate!
-
-      expect(subject).to be_evacuated
-    end
-  end
-end

data/spec/script/path_spec.rb

@@ -1,185 +0,0 @@
-require 'spec_helper'
-require 'helpers/repositories'
-require 'classes/my_script'
-
-require 'ronin/script/path'
-
-describe Script::Path do
-  include Helpers::Repositories
-
-  let(:repo) { repository('scripts') }
-  let(:script_class) { MyScript }
-
-  before { repo.cache_scripts! }
-
-  describe "cached file" do
-    subject { repo.find_script('cached/cached.rb') }
-
-    it "should be saved" do
-      expect(subject).to be_saved
-    end
-
-    it "should have a path" do
-      expect(subject.path).not_to be_nil
-    end
-
-    it "should have a timestamp" do
-      expect(subject.timestamp).not_to be_nil
-    end
-
-    it "should not have updated code" do
-      expect(subject).not_to be_updated
-    end
-
-    it "should not have cache exceptions" do
-      expect(subject.cache_exception).to be_nil
-    end
-
-    it "should not have cache errors" do
-      expect(subject.cache_errors).to be_nil
-    end
-
-    it "should have the model name of the cached object" do
-      expect(subject.class_name).to eq(script_class.name)
-    end
-
-    it "should have the model path of the cached object" do
-      expect(subject.class_path).to eq('my_script')
-    end
-
-    it "should be able to load the Model of the cached object" do
-      expect(subject.script_class).to eq(script_class)
-    end
-
-    it "should be able to load a fresh model from the cached file" do
-      obj = subject.load_script
-
-      expect(obj).not_to be_nil
-      expect(obj.class).to eq(script_class)
-    end
-
-    it "should cache the loaded object along with the cached file" do
-      obj = script_class.first(:script_path => subject)
-      
-      expect(obj).not_to be_nil
-    end
-
-    it "should be able to load the cached object" do
-      expect(subject.cached_script).not_to be_nil
-      expect(subject.cached_script.class).to eq(script_class)
-    end
-
-    it "should call the cache method before saving the new object" do
-      expect(subject.cached_script.name).to eq('cached')
-    end
-
-    it "should delete the cached object along with the cached file" do
-      subject.destroy
-
-      expect(script_class.first(:script_path => subject)).to be_nil
-    end
-  end
-
-  describe "failed cached files" do
-    let(:syntax_error) { repo.find_script('failures/syntax_errors.rb') }
-    let(:load_error) { repo.find_script('failures/load_errors.rb') }
-    let(:name_error) { repo.find_script('failures/name_errors.rb') }
-    let(:no_method_error) { repo.find_script('failures/no_method_errors.rb') }
-    let(:exception) { repo.find_script('failures/exceptions.rb') }
-    let(:validation_error) { repo.find_script('failures/validation_errors.rb') }
-
-    it "should not save new cached files that raised exceptions" do
-      expect(syntax_error).not_to be_saved
-      expect(load_error).not_to be_saved
-      expect(exception).not_to be_saved
-    end
-
-    pending "https://github.com/ronin-rb/ronin/issues/7" do
-      it "should not save new cached files that contain validation errors" do
-        expect(validation_error).to_not be_saved
-      end
-    end
-
-    it "should store syntax errors" do
-      expect(syntax_error.cache_exception).not_to be_nil
-      expect(syntax_error.cache_exception.class).to eq(SyntaxError)
-    end
-
-    it "should store LoadError exceptions" do
-      expect(load_error.cache_exception).not_to be_nil
-      expect(load_error.cache_exception.class).to eq(LoadError)
-    end
-
-    it "should store NameError exceptions" do
-      expect(name_error.cache_exception).not_to be_nil
-      expect(name_error.cache_exception.class).to eq(NameError)
-    end
-
-    it "should store NoMethodError exceptions" do
-      expect(no_method_error.cache_exception).not_to be_nil
-      expect(no_method_error.cache_exception.class).to eq(NoMethodError)
-    end
-
-    it "should store Exceptions raised when creating the fresh object" do
-      expect(exception.cache_exception).not_to be_nil
-    end
-
-    it "should store validation errors" do
-      expect(validation_error.cache_errors).not_to be_nil
-    end
-  end
-
-  describe "unmodified cached file" do
-    subject { repo.find_script('cached/unmodified.rb') }
-
-    it "should not have updated code" do
-      should_not be_updated
-    end
-
-    it "should not re-cache unmodified files" do
-      expect(subject.sync).to be(false)
-    end
-
-    it "should not have cache errors" do
-      expect(subject.cache_errors).to be_nil
-    end
-  end
-
-  describe "modified cached file" do
-    subject { repo.find_script('cached/modified.rb') }
-
-    before do
-      subject.update(:timestamp => (subject.timestamp - 10))
-    end
-
-    it "should not have updated code" do
-      should be_updated
-    end
-
-    it "should re-cache modified files" do
-      expect(subject.sync).to be(true)
-    end
-
-    it "should not have cache errors" do
-      expect(subject.cache_errors).to be_nil
-    end
-  end
-
-  describe "missing cached file" do
-    subject { repo.find_script('cached/missing.rb') }
-
-    before do
-      subject.update(:path => File.join('','missing','file.rb'))
-
-      subject.sync
-    end
-
-    it "should delete the cached files" do
-      expect(described_class.count(:id => subject.id)).to eq(0)
-    end
-
-    it "should delete cached objects for missing files" do
-      expect(script_class.count(:script_path => subject)).to eq(0)
-    end
-  end
-end

data/spec/script/script_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-require 'classes/my_script'
-require 'helpers/repositories'
-
-require 'ronin/script'
-
-describe Script do
-  include Helpers::Repositories
-
-  subject { MyScript }
-
-  let(:repo) { repository('scripts') }
-
-  before { repo.cache_scripts! }
-
-  it "should be a Model" do
-    expect(subject.included_modules).to include(Model)
-  end
-
-  it "should have a name" do
-    expect(subject.included_modules).to include(Model::HasName)
-  end
-
-  it "should have a description" do
-    expect(subject.included_modules).to include(Model::HasDescription)
-  end
-
-  it "should have a version" do
-    expect(subject.included_modules).to include(Model::HasVersion)
-  end
-
-  it "should include ObjectLoader" do
-    expect(subject.included_modules).to include(ObjectLoader)
-  end
-
-  it "should include DataPaths::Finders" do
-    expect(subject.included_modules).to include(DataPaths::Finders)
-  end
-
-  it "should include Parameters" do
-    expect(subject.included_modules).to include(Parameters)
-  end
-
-  it "should include UI::Output::Helpers" do
-    expect(subject.included_modules).to include(UI::Output::Helpers)
-  end
-
-  it "should add the type property to the model" do
-    expect(subject.properties).to be_named(:type)
-  end
-
-  it "should add a relation between Script::Path and the script" do
-    expect(subject.relationships).to be_named(:script_path)
-  end
-
-  describe "#initialize" do
-    it "should initialize attributes" do
-      resource = subject.new(:name => 'test')
-
-      expect(resource.name).to eq('test')
-    end
-
-    it "should initialize parameters" do
-      resource = subject.new(:x => 5)
-
-      expect(resource.x).to eq(5)
-    end
-
-    it "should allow custom initialize methods" do
-      resource = subject.new
-
-      expect(resource.var).to eq(2)
-    end
-  end
-
-  it "should have an short-name" do
-    expect(subject.short_name).to eq('MyScript')
-  end
-
-  describe "load_from" do
-    let(:path) { repo.find_script('my_scripts/test.rb').path }
-
-    subject { Script.load_from(path) }
-
-    it "should have a script_path resource" do
-      expect(subject.script_path).not_to be_nil
-    end
-
-    it "should prepare the object to be cached" do
-      expect(subject.content).to eq('this is a test')
-    end
-
-    it "should preserve instance variables" do
-      expect(subject.var).to eq(2)
-    end
-
-    it "should preserve instance methods" do
-      expect(subject.greeting).to eq('hello')
-    end
-
-    it "should load the script source" do
-      expect(subject).to be_script_loaded
-    end
-  end
-
-  context "when previously cached" do
-    subject { MyScript.first(:name => 'test') }
-
-    it "should have a cached_file resource" do
-      expect(subject.script_path).not_to be_nil
-    end
-
-    it "should be able to load the script source" do
-      subject.load_script!
-
-      expect(subject.greeting).to eq('hello')
-    end
-
-    it "should only load the script source once" do
-      subject.load_script!
-
-      subject.var = false
-      subject.load_script!
-
-      expect(subject.var).to be(false)
-    end
-  end
-end

data/spec/script/testable_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-require 'ronin/script/testable'
-require 'script/classes/testable_class'
-
-describe Script::Testable do
-  subject { TestableClass }
-
-  it "should allow for custom verifications" do
-    obj = subject.new do
-      test do
-        flunk('var must be greater than 2') unless self.var > 2
-      end
-
-      test do
-        flunk('var must be less than 10') unless self.var < 10
-      end
-    end
-
-    obj.var = 20
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 4
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test an expression is true" do
-    obj = subject.new do
-      test? 'var + 2 must equal 4' do
-        (self.var + 2) == 4
-      end
-    end
-
-    obj.var = 1
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 2
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test a method returns an expected value" do
-    obj = subject.new { test_equal :var, 5 }
-
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 5
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test a method does not return an expected value" do
-    obj = subject.new { test_not_equal :var, 5 }
-
-    obj.var = 5
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 2
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test a method returns a non-nil value" do
-    obj = subject.new { test_set :var }
-
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 2
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test a method returns a non-empty value" do
-    obj = subject.new { test_set :var }
-
-    obj.var = ''
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 'hello'
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test a method matches a pattern" do
-    obj = subject.new { test_match :var, /lo/ }
-
-    obj.var = 'goodbye'
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 'hello'
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test a method does not match a pattern" do
-    obj = subject.new { test_no_match :var, /lo/ }
-
-    obj.var = 'hello'
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 'goodbye'
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test a method returns a value in a set of values" do
-    obj = subject.new { test_in :var, [0, 2, 4, 8] }
-
-    obj.var = 3
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 2
-    expect(obj.test!).to be(true)
-  end
-
-  it "should test a method returns a value not in a set of values" do
-    obj = subject.new { test_not_in :var, [0, 2, 4, 8] }
-
-    obj.var = 2
-    expect { obj.test! }.to raise_error(Script::TestFailed)
-
-    obj.var = 3
-    expect(obj.test!).to be(true)
-  end
-end

data/spec/service_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/service'
-
-describe Service do
-  let(:name) { 'Apache' }
-
-  subject { described_class.new(:name => name) }
-  before  { subject.save }
-
-  describe "validations" do
-    it "should require a name" do
-      service = described_class.new
-
-      expect(service).not_to be_valid
-    end
-
-    it "should require a unique name" do
-      service = described_class.new(:name => name)
-
-      expect(service).not_to be_valid
-    end
-  end
-end

data/spec/software_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/software'
-
-describe Software do
-  let(:name)    { 'Test'  }
-  let(:version) { '0.1.0' }
-  let(:vendor)  { 'TestCo' }
-
-  subject do
-    described_class.new(
-      :name    => name,
-      :version => version,
-      :vendor  => {:name => vendor}
-    )
-  end
-
-  describe "validations" do
-    it "should require name and version attributes" do
-      software = described_class.new
-      expect(software).not_to be_valid
-
-      software.name = name
-      expect(software).not_to be_valid
-
-      software.version = version
-      expect(software).to be_valid
-    end
-  end
-
-  describe "#to_s" do
-    it "should be convertable to a String" do
-      expect(subject.to_s).to eq("#{vendor} #{name} #{version}")
-    end
-
-    context "without a vendor" do
-      subject do
-        described_class.new(:name => name, :version => version)
-      end
-
-      it "should ignore the missing vendor information" do
-        expect(subject.to_s).to eq("#{name} #{version}")
-      end
-    end
-  end
-end

data/spec/ui/cli/classes/test_command.rb

@@ -1,26 +0,0 @@
-require 'ronin/ui/cli/command'
-
-class TestCommand < Ronin::UI::CLI::Command
-
-  summary 'Tests the default task'
-
-  usage '[options] PATH FILE [..]'
-
-  examples [
-    'test_command --foo PATH',
-    'test_command --foo PATH FILE ...'
-  ]
-
-  option :foo
-
-  argument :path
-
-  argument :files, :type => Array
-
-  def execute
-    if @foo then 'foo task'
-    else         'default task'
-    end
-  end
-
-end

data/spec/ui/cli/cli_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'ronin/ui/cli/cli'
-
-describe UI::CLI do
-  describe "commands" do
-    subject { described_class.commands }
-
-    it { should_not be_empty }
-
-    it "should replace '/' characters with a ':'" do
-      expect(subject.all? { |command| command.include?('/') }).to be(false)
-    end
-  end
-
-  describe "command" do
-    it "should load classes from 'ronin/ui/cli/commands/'" do
-      command = subject.command('help')
-      
-      expect(command.name).to eq('Ronin::UI::CLI::Commands::Help')
-    end
-
-    it "should load classes from namespaces within 'ronin/ui/cli/commands/'" do
-      command = subject.command('net:proxy')
-      
-      expect(command.name).to eq('Ronin::UI::CLI::Commands::Net::Proxy')
-    end
-
-    it "should raise UnknownCommand for unknown commands" do
-      expect {
-        subject.command('foo')
-      }.to raise_error(described_class::UnknownCommand)
-    end
-  end
-end