ronin 1.5.1 → 2.0.0.beta1

data/spec/model/models/base_model.rb

@@ -1,13 +0,0 @@
-require 'ronin/model/model'
-
-class BaseModel
-
-  include Ronin::Model
-
-  property :id, Serial
-
-  property :name, String
-
-  property :age, Integer
-
-end

data/spec/model/models/described_model.rb

@@ -1,9 +0,0 @@
-require 'ronin/model/has_description'
-
-class DescribedModel
-
-  include Ronin::Model::HasDescription
-
-  property :id, Serial
-
-end

data/spec/model/models/inherited_model.rb

@@ -1,16 +0,0 @@
-require 'ronin/model/model'
-require_relative 'base_model'
-
-class InheritedModel < BaseModel
-
-  include Ronin::Model
-
-  attr_reader :var
-
-  def initialize(attributes={})
-    super(attributes)
-
-    @var = 2
-  end
-
-end

data/spec/model/models/licensed_model.rb

@@ -1,11 +0,0 @@
-require 'ronin/model/has_license'
-
-class LicensedModel
-
-  include Ronin::Model::HasLicense
-
-  property :id, Serial
-
-  property :content, String
-
-end

data/spec/model/models/named_model.rb

@@ -1,9 +0,0 @@
-require 'ronin/model/has_name'
-
-class NamedModel
-
-  include Ronin::Model::HasName
-
-  property :id, Serial
-
-end

data/spec/model/models/titled_model.rb

@@ -1,9 +0,0 @@
-require 'ronin/model/has_title'
-
-class TitledModel
-
-  include Ronin::Model::HasTitle
-
-  property :id, Serial
-
-end

data/spec/model/models/versioned_model.rb

@@ -1,11 +0,0 @@
-require 'ronin/model/has_version'
-
-class VersionedModel
-
-  include Ronin::Model::HasVersion
-
-  property :id, Serial
-
-  property :content, String
-
-end

data/spec/os_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/os'
-
-describe OS do
-  let(:name)    { 'Linux'  }
-  let(:version) { '2.6.11' }
-
-  subject { described_class.new(:name => name, :version => version) }
-
-  describe "predefine" do
-    it "should provide methods for built-in described_classes" do
-      os = described_class.linux
-
-      expect(os.name).to eq('Linux')
-    end
-
-    it "should provide methods for creating described_classes with versions" do
-      os = described_class.linux(version)
-
-      expect(os.version).to eq(version)
-    end
-  end
-
-  describe "validations" do
-    it "should require a name" do
-      os = described_class.new
-      expect(os).not_to be_valid
-
-      os.name = 'test'
-      expect(os).to be_valid
-    end
-  end
-
-  describe "#to_s" do
-    it "should convert both the name and version" do
-      expect(subject.to_s).to eq("#{name} #{version}")
-    end
-
-    context "without a version" do
-      subject { described_class.new(:name => name) }
-
-      it "should convert just the name if there is no version" do
-        expect(subject.to_s).to eq(name)
-      end
-    end
-  end
-end

data/spec/password_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/password'
-
-describe Password do
-  let(:password) { 'secret' }
-
-  subject { described_class.new(:clear_text => password) }
-
-  describe "validations" do
-    it "should require a clear-text password" do
-      pass = described_class.new
-      expect(pass).not_to be_valid
-
-      pass.clear_text = password
-      expect(pass).to be_valid
-    end
-  end
-
-  describe "#digest" do
-    let(:salt) { 'foo' }
-
-    it "should calculate the digest of the password" do
-      digest = subject.digest(:sha1)
-      
-      expect(digest).to eq(Digest::SHA1.hexdigest(password))
-    end
-
-    it "should calculate the digest of the password and prepended salt" do
-      digest = subject.digest(:sha1, :prepend_salt => salt)
-      
-      expect(digest).to eq(Digest::SHA1.hexdigest(salt + password))
-    end
-
-    it "should calculate the digest of the password and appended salt" do
-      digest = subject.digest(:sha1, :append_salt => salt)
-      
-      expect(digest).to eq(Digest::SHA1.hexdigest(password + salt))
-    end
-  end
-
-  describe "#to_s" do
-    it "should include the password" do
-      expect(subject.to_s).to eq(password)
-    end
-  end
-end

data/spec/port_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/port'
-
-describe Port do
-  let(:protocol) { 'tcp' }
-  let(:number)   { 80    }
-
-  subject do
-    described_class.new(:protocol => protocol, :number => number)
-  end
-
-  before { subject.save }
-
-  describe "validations" do
-    it "should require a protocol" do
-      port = described_class.new(:number => port)
-
-      expect(port).not_to be_valid
-    end
-
-    it "should require a port number" do
-      port = described_class.new(:protocol => protocol)
-
-      expect(port).not_to be_valid
-    end
-
-    it "should only allow 'tcp' and 'udp' as protocols" do
-      port = described_class.new(:protocol => 'foo', :number => port)
-
-      expect(port).not_to be_valid
-    end
-
-    it "should require unique protocol/port-number combinations" do
-      port = described_class.new(:protocol => protocol, :number => number)
-      expect(port).not_to be_valid
-    end
-  end
-
-  describe "#to_i" do
-    it "should be convertable to an Integer" do
-      expect(subject.to_i).to eq(number)
-    end
-  end
-
-  describe "#to_s" do
-    it "should include the number and protocol" do
-      expect(subject.to_s).to eq("#{number}/#{protocol}")
-    end
-  end
-end

data/spec/repository_spec.rb

@@ -1,270 +0,0 @@
-require 'spec_helper'
-require 'helpers/repositories'
-
-require 'ronin/repository'
-
-describe Repository do
-  include Helpers::Repositories
-
-  subject { described_class }
-
-  describe "find" do
-    it "should be able to retrieve an Repository by name" do
-      repo = subject.find('local')
-
-      expect(repo.name).to eq('local')
-    end
-
-    it "should be able to retrieve an Repository by name and domain" do
-      repo = subject.find('installed@github.com')
-
-      expect(repo.name).to eq('installed')
-      expect(repo.domain).to eq('github.com')
-    end
-
-    it "should raise RepositoryNotFound for unknown Repository names" do
-      expect {
-        subject.find('bla')
-      }.to raise_error(RepositoryNotFound)
-    end
-
-    it "should raise RepositoryNotFound for unknown Repository names or domains" do
-      expect {
-        subject.find('bla/bla')
-      }.to raise_error(RepositoryNotFound)
-    end
-  end
-
-  describe "add" do
-    it "should not add Repositorys without a path property" do
-      expect {
-        subject.add
-      }.to raise_error(ArgumentError)
-    end
-
-    it "should not add Repositorys that do not point to a directory" do
-      expect {
-        subject.add(:path => 'path/to/nowhere')
-      }.to raise_error(RepositoryNotFound)
-    end
-
-    it "should not allow adding an Repository from the same path twice" do
-      expect {
-        subject.add(:path => repository('local').path)
-      }.to raise_error(DuplicateRepository)
-    end
-
-    it "should not allow adding an Repository that was already installed" do
-      expect {
-        subject.add(:path => repository('installed').path)
-      }.to raise_error(DuplicateRepository)
-    end
-  end
-
-  describe "install" do
-    it "should not allow installing an Repository with no URI" do
-      expect {
-        subject.install
-      }.to raise_error(ArgumentError)
-    end
-
-    it "should not allow installing an Repository that was already added" do
-      expect {
-        subject.install(:uri => repository('remote').uri)
-      }.to raise_error(DuplicateRepository)
-    end
-
-    it "should not allow installing an Repository from the same URI twice" do
-      expect {
-        subject.install(:uri => repository('installed').uri)
-      }.to raise_error(DuplicateRepository)
-    end
-  end
-
-  describe "#domain" do
-    it "should be considered local for 'localhost' domains" do
-      repo = repository('local')
-
-      expect(repo).to be_local
-      expect(repo).not_to be_remote
-    end
-
-    it "should be considered remote for non 'localhost' domains" do
-      repo = repository('installed')
-
-      expect(repo).to be_remote
-      expect(repo).not_to be_local
-    end
-  end
-
-  describe "#initialize" do
-    it "should default the 'name' property to the name of the Repository directory" do
-      repo = subject.new(
-        :path => File.join(Helpers::Repositories::DIR,'local')
-      )
-
-      expect(repo.name).to eq('local')
-    end
-
-    it "should default the 'installed' property to false" do
-      repo = subject.new(
-        :path => File.join(Helpers::Repositories::DIR,'local'),
-        :uri => 'git://github.com/path/to/local.git'
-      )
-
-      expect(repo.installed).to be(false)
-    end
-  end
-
-  describe "#initialize_metadata" do
-    subject { repository('installed') }
-
-    it "should load the title" do
-      expect(subject.title).to eq('Installed Repo')
-    end
-
-    it "should load the website" do
-      website = Addressable::URI.parse('http://ronin.rubyforge.org/')
-
-      expect(subject.website).to eq(website)
-    end
-
-    it "should load the license" do
-      expect(subject.license).not_to be_nil
-      expect(subject.license.name).to eq('GPL-2')
-    end
-
-    it "should load the maintainers" do
-      author = subject.authors.find { |author|
-        author.name == 'Postmodern' &&
-        author.email == 'postmodern.mod3@gmail.com'
-      }
-      
-      expect(author).not_to be_nil
-    end
-
-    it "should load the description" do
-      expect(subject.description).to eq(%{This is a test repo used in Ronin's specs.})
-    end
-  end
-
-  describe "#activate!" do
-    subject { repository('local') }
-
-    before { subject.activate! }
-
-    it "should load the init.rb file if present" do
-      expect($local_repo_loaded).to be(true)
-    end
-
-    it "should make the lib directory accessible to Kernel#require" do
-      expect(require('stuff/test')).to be(true)
-    end
-
-    after { subject.deactivate! }
-  end
-
-  describe "#deactivate!" do
-    subject { repository('local') }
-
-    before do
-      subject.activate!
-      subject.deactivate!
-    end
-
-    it "should make the lib directory unaccessible to Kernel#require" do
-      expect {
-        require 'stuff/another_test'
-      }.to raise_error(LoadError)
-    end
-  end
-
-  describe "#each_script" do
-    subject { repository('scripts') }
-
-    it "should list the contents of the 'cache/' directory" do
-      expect(subject.each_script.to_a).not_to be_empty
-    end
-
-    it "should only list '.rb' files" do
-      expect(subject.each_script.map { |path|
-        path.extname
-      }.uniq).to eq(['.rb'])
-    end
-  end
-
-  describe "#script_paths" do
-    subject { repository('scripts') }
-
-    describe "#cache_scripts!" do
-      before { subject.cache_scripts! }
-
-      it "should be populated script_paths" do
-        expect(subject.script_paths).not_to be_empty
-      end
-
-      it "should recover from files that contain syntax errors" do
-        expect(subject.find_script('failures/syntax_errors.rb')).not_to be_nil
-      end
-
-      it "should recover from files that raised exceptions" do
-        expect(subject.find_script('failures/exceptions.rb')).not_to be_nil
-      end
-
-      it "should recover from files that raise NoMethodError" do
-        expect(subject.find_script('failures/no_method_errors.rb')).not_to be_nil
-      end
-
-      it "should recover from files that have validation errors" do
-        expect(subject.find_script('failures/validation_errors.rb')).not_to be_nil
-      end
-
-      it "should clear script_paths before re-populate them" do
-        paths = subject.script_paths.length
-        subject.cache_scripts!
-
-        expect(subject.script_paths.length).to eq(paths)
-      end
-
-      it "should be populated using the paths in the 'cache/' directory" do
-        expect(subject.script_paths.map { |file|
-          file.path
-        }).to eq(subject.each_script.to_a)
-      end
-    end
-
-    describe "#sync_scripts!" do
-      before do
-        subject.cache_scripts!
-
-        script_path = subject.find_script('cached/modified.rb')
-
-        script_path.timestamp -= 10
-        script_path.save
-
-        script_path = subject.find_script('cached/cached.rb')
-        script_path.destroy!
-
-        subject.sync_scripts!
-      end
-
-      it "should update stale cached files" do
-        script_path = subject.find_script('cached/modified.rb')
-
-        expect(script_path.timestamp).to eq(File.mtime(script_path.path))
-      end
-
-      it "should cache new files" do
-        expect(subject.find_script('cached/cached.rb')).not_to be_nil
-      end
-    end
-
-    describe "#clean_scripts!" do
-      before { subject.clean_scripts! }
-
-      it "should clear the script_paths" do
-        expect(subject.script_paths).to be_empty
-      end
-    end
-  end
-end

data/spec/ronin_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'ronin/ronin'
-require 'ronin/version'
-
-describe Ronin do
-  it "should have a version" do
-    version = subject.const_get('VERSION')
-
-    expect(version).not_to be_nil
-    expect(version).not_to be_empty
-  end
-
-  it "should include AutoLoad" do
-    expect(subject).to include(AutoLoad)
-  end
-
-  it "should add a const_missing method when included" do
-    base_class = Class.new
-    base_class.send :include, subject
-
-    subject.const_set('SOME_CONSTANT',1)
-
-    expect(base_class.const_get('SOME_CONSTANT')).to eq(1)
-  end
-end

data/spec/script/buildable_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'ronin/script/buildable'
-require 'script/classes/buildable_class'
-
-describe Script::Buildable do
-  subject do
-    obj = BuildableClass.new
-    obj.instance_eval do
-      build { @output = "hello #{@var}" }
-    end
-
-    obj
-  end
-
-  it "should not be built by default" do
-    expect(subject).not_to be_built
-  end
-
-  it "should include Testable" do
-    expect(subject.class.included_modules).to include(Script::Testable)
-  end
-
-  describe "#build!" do
-    it "should call the build block" do
-      subject.build!
-
-      expect(subject.output).to eq("hello world")
-    end
-
-    it "should mark the script as built" do
-      subject.build!
-
-      expect(subject).to be_built
-    end
-
-    it "should accept parameters as options" do
-      subject.build!(:var => 'dave')
-
-      expect(subject.output).to eq("hello dave")
-      expect(subject.var).to eq('dave')
-    end
-  end
-
-  describe "#verify!" do
-    it "should raise a NotBuilt exception when verifying unbuilt scripts" do
-      expect {
-        subject.test!
-      }.to raise_error(Script::NotBuilt)
-    end
-  end
-end

data/spec/script/classes/buildable_class.rb

@@ -1,15 +0,0 @@
-require 'ronin/script'
-require 'ronin/script/buildable'
-
-class BuildableClass
-
-  include Ronin::Script
-  include Ronin::Script::Buildable
-
-  property :id, Serial
-
-  parameter :var, :default => 'world'
-
-  attr_reader :output
-
-end

data/spec/script/classes/deployable_class.rb

@@ -1,13 +0,0 @@
-require 'ronin/script'
-require 'ronin/script/deployable'
-
-class DeployableClass
-
-  include Ronin::Script
-  include Ronin::Script::Deployable
-
-  property :id, Serial
-
-  parameter :var, :default => 5
-
-end

data/spec/script/classes/script_class.rb

@@ -1,19 +0,0 @@
-require 'ronin/script'
-
-class ScriptClass
-
-  include Ronin::Script
-
-  property :id, Serial
-
-  parameter :x, :default => 1
-
-  attr_reader :y
-
-  def initialize(options={})
-    super(options)
-
-    @y = 2
-  end
-
-end

data/spec/script/classes/testable_class.rb

@@ -1,19 +0,0 @@
-require 'ronin/script'
-require 'ronin/script/testable'
-
-class TestableClass
-
-  include Ronin::Script
-  include Ronin::Script::Testable
-
-  property :id, Serial
-
-  parameter :var
-
-  def initialize(attributes={},&block)
-    super(attributes)
-
-    instance_eval(&block) if block
-  end
-
-end