ronin 1.5.0 → 1.5.1

data/spec/port_spec.rb

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

@@ -12,72 +12,72 @@ describe Repository do
     it "should be able to retrieve an Repository by name" do
       repo = subject.find('local')
 
-      repo.name.should == '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')
 
-      repo.name.should == 'installed'
-      repo.domain.should == '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
-      lambda {
+      expect {
         subject.find('bla')
-      }.should raise_error(RepositoryNotFound)
+      }.to raise_error(RepositoryNotFound)
     end
 
     it "should raise RepositoryNotFound for unknown Repository names or domains" do
-      lambda {
+      expect {
         subject.find('bla/bla')
-      }.should raise_error(RepositoryNotFound)
+      }.to raise_error(RepositoryNotFound)
     end
   end
 
   describe "add" do
     it "should not add Repositorys without a path property" do
-      lambda {
+      expect {
         subject.add
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it "should not add Repositorys that do not point to a directory" do
-      lambda {
+      expect {
         subject.add(:path => 'path/to/nowhere')
-      }.should raise_error(RepositoryNotFound)
+      }.to raise_error(RepositoryNotFound)
     end
 
     it "should not allow adding an Repository from the same path twice" do
-      lambda {
+      expect {
         subject.add(:path => repository('local').path)
-      }.should raise_error(DuplicateRepository)
+      }.to raise_error(DuplicateRepository)
     end
 
     it "should not allow adding an Repository that was already installed" do
-      lambda {
+      expect {
         subject.add(:path => repository('installed').path)
-      }.should raise_error(DuplicateRepository)
+      }.to raise_error(DuplicateRepository)
     end
   end
 
   describe "install" do
     it "should not allow installing an Repository with no URI" do
-      lambda {
+      expect {
         subject.install
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it "should not allow installing an Repository that was already added" do
-      lambda {
+      expect {
         subject.install(:uri => repository('remote').uri)
-      }.should raise_error(DuplicateRepository)
+      }.to raise_error(DuplicateRepository)
     end
 
     it "should not allow installing an Repository from the same URI twice" do
-      lambda {
+      expect {
         subject.install(:uri => repository('installed').uri)
-      }.should raise_error(DuplicateRepository)
+      }.to raise_error(DuplicateRepository)
     end
   end
 
@@ -85,15 +85,15 @@ describe Repository do
     it "should be considered local for 'localhost' domains" do
       repo = repository('local')
 
-      repo.should be_local
-      repo.should_not be_remote
+      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')
 
-      repo.should be_remote
-      repo.should_not be_local
+      expect(repo).to be_remote
+      expect(repo).not_to be_local
     end
   end
 
@@ -103,7 +103,7 @@ describe Repository do
         :path => File.join(Helpers::Repositories::DIR,'local')
       )
 
-      repo.name.should == 'local'
+      expect(repo.name).to eq('local')
     end
 
     it "should default the 'installed' property to false" do
@@ -112,7 +112,7 @@ describe Repository do
         :uri => 'git://github.com/path/to/local.git'
       )
 
-      repo.installed.should == false
+      expect(repo.installed).to be(false)
     end
   end
 
@@ -120,18 +120,18 @@ describe Repository do
     subject { repository('installed') }
 
     it "should load the title" do
-      subject.title.should == 'Installed Repo'
+      expect(subject.title).to eq('Installed Repo')
     end
 
     it "should load the website" do
       website = Addressable::URI.parse('http://ronin.rubyforge.org/')
 
-      subject.website.should == website
+      expect(subject.website).to eq(website)
     end
 
     it "should load the license" do
-      subject.license.should_not be_nil
-      subject.license.name.should == 'GPL-2'
+      expect(subject.license).not_to be_nil
+      expect(subject.license.name).to eq('GPL-2')
     end
 
     it "should load the maintainers" do
@@ -140,41 +140,42 @@ describe Repository do
         author.email == 'postmodern.mod3@gmail.com'
       }
       
-      author.should_not be_nil
+      expect(author).not_to be_nil
     end
 
     it "should load the description" do
-      subject.description.should == %{This is a test repo used in Ronin's specs.}
+      expect(subject.description).to eq(%{This is a test repo used in Ronin's specs.})
     end
   end
 
   describe "#activate!" do
     subject { repository('local') }
 
-    before(:all) do
-      subject.activate!
-    end
+    before { subject.activate! }
 
     it "should load the init.rb file if present" do
-      $local_repo_loaded.should == true
+      expect($local_repo_loaded).to be(true)
     end
 
     it "should make the lib directory accessible to Kernel#require" do
-      require('stuff/test').should == true
+      expect(require('stuff/test')).to be(true)
     end
+
+    after { subject.deactivate! }
   end
 
   describe "#deactivate!" do
     subject { repository('local') }
 
-    before(:all) do
+    before do
+      subject.activate!
       subject.deactivate!
     end
 
     it "should make the lib directory unaccessible to Kernel#require" do
-      lambda {
+      expect {
         require 'stuff/another_test'
-      }.should raise_error(LoadError)
+      }.to raise_error(LoadError)
     end
   end
 
@@ -182,13 +183,13 @@ describe Repository do
     subject { repository('scripts') }
 
     it "should list the contents of the 'cache/' directory" do
-      subject.each_script.to_a.should_not be_empty
+      expect(subject.each_script.to_a).not_to be_empty
     end
 
     it "should only list '.rb' files" do
-      subject.each_script.map { |path|
+      expect(subject.each_script.map { |path|
         path.extname
-      }.uniq.should == ['.rb']
+      }.uniq).to eq(['.rb'])
     end
   end
 
@@ -196,44 +197,44 @@ describe Repository do
     subject { repository('scripts') }
 
     describe "#cache_scripts!" do
-      before(:all) { subject.cache_scripts! }
+      before { subject.cache_scripts! }
 
       it "should be populated script_paths" do
-        subject.script_paths.should_not be_empty
+        expect(subject.script_paths).not_to be_empty
       end
 
       it "should recover from files that contain syntax errors" do
-        subject.find_script('failures/syntax_errors.rb').should_not be_nil
+        expect(subject.find_script('failures/syntax_errors.rb')).not_to be_nil
       end
 
       it "should recover from files that raised exceptions" do
-        subject.find_script('failures/exceptions.rb').should_not be_nil
+        expect(subject.find_script('failures/exceptions.rb')).not_to be_nil
       end
 
       it "should recover from files that raise NoMethodError" do
-        subject.find_script('failures/no_method_errors.rb').should_not be_nil
+        expect(subject.find_script('failures/no_method_errors.rb')).not_to be_nil
       end
 
       it "should recover from files that have validation errors" do
-        subject.find_script('failures/validation_errors.rb').should_not be_nil
+        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!
 
-        subject.script_paths.length.should == paths
+        expect(subject.script_paths.length).to eq(paths)
       end
 
       it "should be populated using the paths in the 'cache/' directory" do
-        subject.script_paths.map { |file|
+        expect(subject.script_paths.map { |file|
           file.path
-        }.should == subject.each_script.to_a
+        }).to eq(subject.each_script.to_a)
       end
     end
 
     describe "#sync_scripts!" do
-      before(:all) do
+      before do
         subject.cache_scripts!
 
         script_path = subject.find_script('cached/modified.rb')
@@ -250,21 +251,19 @@ describe Repository do
       it "should update stale cached files" do
         script_path = subject.find_script('cached/modified.rb')
 
-        script_path.timestamp.should == File.mtime(script_path.path)
+        expect(script_path.timestamp).to eq(File.mtime(script_path.path))
       end
 
       it "should cache new files" do
-        subject.find_script('cached/cached.rb').should_not be_nil
+        expect(subject.find_script('cached/cached.rb')).not_to be_nil
       end
     end
 
     describe "#clean_scripts!" do
-      before(:all) do
-        subject.clean_scripts!
-      end
+      before { subject.clean_scripts! }
 
       it "should clear the script_paths" do
-        subject.script_paths.should be_empty
+        expect(subject.script_paths).to be_empty
       end
     end
   end

data/spec/ronin_spec.rb

@@ -6,12 +6,12 @@ describe Ronin do
   it "should have a version" do
     version = subject.const_get('VERSION')
 
-    version.should_not be_nil
-    version.should_not be_empty
+    expect(version).not_to be_nil
+    expect(version).not_to be_empty
   end
 
   it "should include AutoLoad" do
-    subject.should include(AutoLoad)
+    expect(subject).to include(AutoLoad)
   end
 
   it "should add a const_missing method when included" do
@@ -20,6 +20,6 @@ describe Ronin do
 
     subject.const_set('SOME_CONSTANT',1)
 
-    base_class.const_get('SOME_CONSTANT').should == 1
+    expect(base_class.const_get('SOME_CONSTANT')).to eq(1)
   end
 end

data/spec/script/buildable_spec.rb

@@ -13,39 +13,39 @@ describe Script::Buildable do
   end
 
   it "should not be built by default" do
-    subject.should_not be_built
+    expect(subject).not_to be_built
   end
 
   it "should include Testable" do
-    subject.class.included_modules.should include(Script::Testable)
+    expect(subject.class.included_modules).to include(Script::Testable)
   end
 
   describe "#build!" do
     it "should call the build block" do
       subject.build!
 
-      subject.output.should == "hello world"
+      expect(subject.output).to eq("hello world")
     end
 
     it "should mark the script as built" do
       subject.build!
 
-      subject.should be_built
+      expect(subject).to be_built
     end
 
     it "should accept parameters as options" do
       subject.build!(:var => 'dave')
 
-      subject.output.should == "hello dave"
-      subject.var.should == '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
-      lambda {
+      expect {
         subject.test!
-      }.should raise_error(Script::NotBuilt)
+      }.to raise_error(Script::NotBuilt)
     end
   end
 end

data/spec/script/deployable_spec.rb

@@ -16,32 +16,32 @@ describe Script::Deployable do
   end
 
   it "should include Testable" do
-    subject.class.included_modules.should include(Script::Testable)
+    expect(subject.class.included_modules).to include(Script::Testable)
   end
 
   it "should not be deployed by default" do
-    subject.should_not be_deployed
+    expect(subject).not_to be_deployed
   end
 
   describe "#deploy!" do
     it "should test! the script before deploying it" do
       subject.var = -1
 
-      lambda {
+      expect {
         subject.deploy!
-      }.should raise_error
+      }.to raise_error(RuntimeError)
     end
 
     it "should mark the script deployed" do
       subject.deploy!
 
-      subject.should be_deployed
+      expect(subject).to be_deployed
     end
 
     it "should not mark the script as evacuated" do
       subject.deploy!
 
-      subject.should_not be_evacuated
+      expect(subject).not_to be_evacuated
     end
   end
 
@@ -49,7 +49,7 @@ describe Script::Deployable do
     it "should mark the script as evacuated" do
       subject.evacuate!
 
-      subject.should be_evacuated
+      expect(subject).to be_evacuated
     end
   end
 end