ronin 1.5.0 → 1.5.1

data/spec/license_spec.rb

@@ -1,19 +1,25 @@
 require 'spec_helper'
+
 require 'ronin/license'
 
 describe License do
-  it "should require name and description attributes" do
-    license = License.new
-    license.should_not be_valid
+  describe "validations" do
+    it "should require name and description attributes" do
+      expect(subject).not_to be_valid
 
-    license.name = 'joke'
-    license.should_not be_valid
+      subject.name = 'joke'
+      expect(subject).not_to be_valid
 
-    license.description = "yep, it's a joke."
-    license.should be_valid
+      subject.description = "yep, it's a joke."
+      expect(subject).to be_valid
+    end
   end
 
-  it "should provide built-in licenses"do
-    License.cc_by.should_not be_nil
+  describe "predefined licenses" do
+    subject { described_class }
+
+    it "should provide built-in licenses"do
+      expect(subject.cc_by).not_to be_nil
+    end
   end
 end

data/spec/mac_address_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
+
 require 'ronin/mac_address'
 
 describe MACAddress do
   let(:address) { '00:01:02:03:04:05' }
 
-  subject { MACAddress.new(:address => address) }
+  subject { described_class.new(:address => address) }
 
   describe "extract" do
     subject { described_class }
@@ -14,7 +15,7 @@ describe MACAddress do
     let(:text)  { "MACs: #{mac1}, #{mac2}." }
 
     it "should extract multiple MAC Addresses from text" do
-      subject.extract(text).should == [mac1, mac2]
+      expect(subject.extract(text)).to eq([mac1, mac2])
     end
 
     it "should yield the extracted MAC Addresses if a block is given" do
@@ -22,17 +23,25 @@ describe MACAddress do
 
       subject.extract(text) { |mac| macs << mac }
 
-      macs.should == [mac1, mac2]
+      expect(macs).to eq([mac1, mac2])
     end
   end
 
-  it "should require an address" do
-    mac = MACAddress.new
+  describe "validations" do
+    it "should require an address" do
+      mac = described_class.new
+      expect(mac).not_to be_valid
 
-    mac.should_not be_valid
+      mac.address = address
+      expect(mac).to be_valid
+    end
   end
 
-  it "should convert the MAC Address to an Integer" do
-    subject.to_i.should == 0x000102030405
+  describe "#to_i" do
+    let(:integer) { 0x000102030405 }
+
+    it "should convert the MAC Address to an Integer" do
+      expect(subject.to_i).to eq(integer)
+    end
   end
 end

data/spec/model/has_authors_spec.rb

@@ -4,57 +4,76 @@ require 'model/models/authored_model'
 require 'ronin/model/has_authors'
 
 describe Model::HasAuthors do
-  subject { AuthoredModel }
+  let(:model) { AuthoredModel }
 
-  before(:all) do
-    subject.auto_migrate!
+  describe ".included" do
+    subject { model }
 
-    resource = subject.new(:content => 'Test')
-    resource.author(
-      :name => 'Alice',
-      :email => 'alice@example.com',
-      :organization => 'Crew'
-    )
+    it "should include Ronin::Model" do
+      expect(subject.ancestors).to include(Model)
+    end
 
-    resource.save
-  end
+    it "should define an authors relationship" do
+      relationship = subject.relationships['authors']
 
-  it "should include Ronin::Model" do
-    subject.ancestors.should include(Model)
-  end
+      expect(relationship).not_to be_nil
+      expect(relationship.child_model).to eq(Author)
+    end
 
-  it "should define an authors relationship" do
-    relationship = subject.relationships['authors']
+    it "should define relationships with Author" do
+      relationship = Author.relationships['authored_models']
 
-    relationship.should_not be_nil
-    relationship.child_model.should == Author
+      expect(relationship).not_to be_nil
+      expect(relationship.child_model).to eq(subject)
+    end
   end
 
-  it "should define relationships with Author" do
-    relationship = Author.relationships['authored_models']
-    
-    relationship.should_not be_nil
-    relationship.child_model.should == subject
-  end
+  let(:author_name) { 'Alice' }
+  let(:author_email) { 'alice@example.com' }
+  let(:organization) { 'Org' }
 
-  it "should allow adding authors to a resource" do
-    resource = subject.new
-    resource.author(:name => 'Alice', :email => 'alice@example.com')
+  describe "#author" do
+    subject do
+      model.new.tap do |resource|
+        resource.author(:name => author_name, :email => author_email)
+      end
+    end
 
-    resource.authors.should_not be_empty
+    it "should allow adding authors to a resource" do
+      expect(subject.authors).not_to be_empty
+      expect(subject.authors[0].name).to be(author_name)
+      expect(subject.authors[0].email).to be(author_email)
+    end
   end
 
-  it "should allow querying resources based on their Author" do
-    resources = subject.written_by('Alice')
+  describe ".written_by" do
+    subject { model }
 
-    resources.length.should == 1
-    resources[0].authors[0].name.should == 'Alice'
-  end
+    before do
+      resource = subject.new(:content => 'Test')
+      resource.author(
+        :name => author_name,
+        :email => author_email,
+        :organization => organization
+      )
+
+      resource.save
+    end
+
+    it "should allow querying resources based on their Author" do
+      resources = subject.written_by(author_name)
+
+      expect(resources.length).to eq(1)
+      expect(resources[0].authors[0].name).to be == author_name
+    end
+
+    it "should allow querying resources based on their Organization" do
+      resources = subject.written_for(organization)
 
-  it "should allow querying resources based on their Organization" do
-    resources = subject.written_for('Crew')
+      expect(resources.length).to eq(1)
+      expect(resources[0].authors[0].organization).to be == organization
+    end
 
-    resources.length.should == 1
-    resources[0].authors[0].organization.should == 'Crew'
+    after { subject.destroy }
   end
 end

data/spec/model/has_description_spec.rb

@@ -4,60 +4,73 @@ require 'model/models/described_model'
 require 'ronin/model/has_description'
 
 describe Model::HasDescription do
-  subject { DescribedModel }
+  let(:model) { DescribedModel }
 
-  before(:all) { subject.auto_migrate! }
+  describe ".included" do
+    subject { model }
 
-  it "should include Ronin::Model" do
-    subject.ancestors.should include(Model)
-  end
+    it "should include Ronin::Model" do
+      expect(subject.ancestors).to include(Model)
+    end
 
-  it "should define a description property" do
-    subject.properties.should be_named(:description)
+    it "should define a description property" do
+      expect(subject.properties).to be_named(:description)
+    end
   end
 
   describe "#description" do
-    let(:resource) { DescribedModel.new }
+    subject { model.new }
 
     it "should allow the setting of the description" do
-      resource.description = 'test one'
-      resource.description.should == 'test one'
+      subject.description = 'test one'
+      expect(subject.description).to eq('test one')
     end
 
     it "should strip leading and tailing white-space" do
-      resource.description = %{   test two    }
+      subject.description = %{   test two    }
 
-      resource.description.should == 'test two'
+      expect(subject.description).to eq('test two')
     end
 
     it "should strip leading and tailing white-space from each line" do
-      resource.description = %{
+      subject.description = %{
         test
         three
       }
 
-      resource.description.should == "test\nthree"
+      expect(subject.description).to eq("test\nthree")
     end
 
     it "should preserve non-bordering empty lines" do
-      resource.description = %{
+      subject.description = %{
         test
 
         four
       }
 
-      resource.description.should == "test\n\nfour"
+      expect(subject.description).to eq("test\n\nfour")
     end
   end
 
-  it "should be able to find resources with similar descriptions" do
-    subject.create!(:description => 'foo one')
-    subject.create!(:description => 'foo bar two')
+  describe ".describing" do
+    subject { model }
+
+    let(:description1) { 'foo one' }
+    let(:description2) { 'foo bar two' }
 
-    resources = subject.describing('foo')
+    before do
+      subject.create!(:description => description1)
+      subject.create!(:description => description2)
+    end
+
+    it "should be able to find resources with similar descriptions" do
+      resources = subject.describing('foo')
+
+      expect(resources.length).to be(2)
+      expect(resources[0].description).to be == description1
+      expect(resources[1].description).to be == description2
+    end
 
-    resources.length.should == 2
-    resources[0].description.should == 'foo one'
-    resources[1].description.should == 'foo bar two'
+    after { subject.destroy }
   end
 end

data/spec/model/has_license_spec.rb

@@ -4,60 +4,70 @@ require 'model/models/licensed_model'
 require 'ronin/model/has_license'
 
 describe Model::HasLicense do
-  subject { LicensedModel }
+  let(:model) { LicensedModel }
 
-  before(:all) do
-    subject.auto_migrate!
+  describe ".included" do
+    subject { model }
 
-    subject.create(
-      :content => 'stuff here',
-      :license => License.gpl2
-    )
-  end
+    it "should include Ronin::Model" do
+      expect(subject.ancestors).to include(Model)
+    end
 
-  it "should include Ronin::Model" do
-    subject.ancestors.should include(Model)
-  end
+    it "should define a license relationship" do
+      relationship = subject.relationships['license']
 
-  it "should define a license relationship" do
-    relationship = subject.relationships['license']
+      expect(relationship).not_to be_nil
+      expect(relationship.parent_model).to eq(License)
+    end
 
-    relationship.should_not be_nil
-    relationship.parent_model.should == License
-  end
+    it "should define relationships with License" do
+      relationship = License.relationships['licensed_models']
 
-  it "should define relationships with License" do
-    relationship = License.relationships['licensed_models']
-    
-    relationship.should_not be_nil
-    relationship.child_model.should == subject
+      expect(relationship).not_to be_nil
+      expect(relationship.child_model).to eq(subject)
+    end
   end
 
-  it "should not require a license" do
-    resource = subject.new(:content => 'bla')
+  describe "validations" do
+    subject { model }
 
-    resource.should be_valid
+    it "should not require a license" do
+      resource = subject.new(:content => 'bla')
+
+      expect(resource).to be_valid
+    end
   end
 
-  describe "licensed_under" do
+  describe ".licensed_under" do
+    subject { model }
+
+    before do
+      subject.create(
+        :content => 'stuff here',
+        :license => License.gpl2
+      )
+    end
+
     let(:license) { License.gpl2 }
 
     it "should accept License resources" do
       resource = subject.licensed_under(license).first
 
-      resource.license.should == license
+      expect(resource.license).to be == license
     end
 
     it "should accept the names of predefined Licenses" do
       resource = subject.licensed_under(:gpl2).first
 
-      resource.license.should == license
+      expect(resource.license).to be == license
     end
 
     it "should accept the names of licenses" do
       resource = subject.licensed_under('GPL-2').first
 
-      resource.license.should == license
+      expect(resource.license).to be == license
     end
+
+    after { subject.destroy }
   end
 end

data/spec/model/has_name_spec.rb

@@ -4,34 +4,51 @@ require 'model/models/named_model'
 require 'ronin/model/has_name'
 
 describe Model::HasName do
-  subject { NamedModel }
+  let(:model) { NamedModel }
 
-  before(:all) { subject.auto_migrate! }
+  describe ".included" do
+    subject { model }
 
-  it "should include Ronin::Model" do
-    subject.ancestors.should include(Model)
-  end
+    it "should include Ronin::Model" do
+      expect(subject.ancestors).to include(Model)
+    end
 
-  it "should define a name property" do
-    subject.properties.should be_named(:name)
+    it "should define a name property" do
+      expect(subject.properties).to be_named(:name)
+    end
   end
 
-  it "should require a name" do
-    resource = subject.new
-    resource.should_not be_valid
+  describe "validations" do
+    subject { model }
+
+    it "should require a name" do
+      resource = subject.new
+      expect(resource).not_to be_valid
 
-    resource.name = 'foo'
-    resource.should be_valid
+      resource.name = 'foo'
+      expect(resource).to be_valid
+    end
   end
 
-  it "should be able to find resources with similar names" do
-    subject.create!(:name => 'foo1')
-    subject.create!(:name => 'foo2')
+  describe ".named" do
+    subject { model }
+
+    let(:name1) { 'foo1' }
+    let(:name2) { 'foo2' }
+
+    before do
+      subject.create!(:name => name1)
+      subject.create!(:name => name2)
+    end
+
+    it "should be able to find resources with similar names" do
+      resources = subject.named('foo')
 
-    resources = subject.named('foo')
+      expect(resources.length).to eq(2)
+      expect(resources[0].name).to be == name1
+      expect(resources[1].name).to be == name2
+    end
 
-    resources.length.should == 2
-    resources[0].name.should == 'foo1'
-    resources[1].name.should == 'foo2'
+    after { subject.destroy }
   end
 end