ronin 1.5.0 → 1.5.1

data/spec/model/has_title_spec.rb

@@ -4,26 +4,39 @@ require 'model/models/titled_model'
 require 'ronin/model/has_title'
 
 describe Model::HasTitle do
-  subject { TitledModel }
+  let(:model) { TitledModel }
 
-  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 title property" do
-    subject.properties.should be_named(:title)
+    it "should define a title property" do
+      expect(subject.properties).to be_named(:title)
+    end
   end
 
-  it "should be able to find resources with similar titles" do
-    subject.create!(:title => 'Foo one')
-    subject.create!(:title => 'Foo bar two')
+  describe ".titled" do
+    subject { model }
+
+    let(:title1) { 'Foo one' }
+    let(:title2) { 'Foo bar two' }
+
+    before do
+      subject.create!(:title => title1)
+      subject.create!(:title => title2)
+    end
+
+    it "should be able to find resources with similar titles" do
+      resources = subject.titled('Foo')
 
-    resources = subject.titled('Foo')
+      expect(resources.length).to eq(2)
+      expect(resources[0].title).to be == title1
+      expect(resources[1].title).to be == title2
+    end
 
-    resources.length.should == 2
-    resources[0].title.should == 'Foo one'
-    resources[1].title.should == 'Foo bar two'
+    after { subject.destroy }
   end
 end

data/spec/model/has_version_spec.rb

@@ -4,55 +4,84 @@ require 'model/models/versioned_model'
 require 'ronin/model/has_version'
 
 describe Model::HasVersion do
-  subject { VersionedModel }
+  let(:model) { VersionedModel }
 
-  before(:all) do
-    subject.auto_migrate!
+  describe ".included" do
+    subject { model }
 
-    subject.create(
-      :version => '1.1',
-      :content => 'Foo'
-    )
+    it "should include Ronin::Model" do
+      expect(subject.ancestors).to include(Model)
+    end
 
-    subject.create(
-      :version => '1.1',
-      :content => 'Bar'
-    )
+    it "should define a version property" do
+      expect(subject.properties).to be_named(:version)
+    end
 
-    subject.create(
-      :version => '1.2',
-      :content => 'Foo'
-    )
-  end
+    it "should default the version property to '0.1'" do
+      resource = subject.new
 
-  it "should include Ronin::Model" do
-    subject.ancestors.should include(Model)
+      expect(resource.version).to eq('0.1')
+    end
   end
 
-  it "should define a version property" do
-    subject.properties.should be_named(:version)
-  end
+  describe ".revision" do
+    subject { model }
 
-  it "should default the version property to '1.0'" do
-    resource = subject.new
+    before do
+      subject.create(
+        :version => '1.1',
+        :content => 'one'
+      )
 
-    resource.version.should == '0.1'
-  end
+      subject.create(
+        :version => '1.1',
+        :content => 'two'
+      )
+
+      subject.create(
+        :version => '1.2',
+        :content => 'three'
+      )
+    end
+
+    it "should allow querying specific revisions" do
+      resources = subject.revision('1.1')
 
-  it "should allow querying specific revisions" do
-    resources = subject.revision('1.1')
+      expect(resources.length).to eq(2)
+      expect(resources[0].version).to eq('1.1')
+      expect(resources[0].content).to eq('one')
 
-    resources.length.should == 2
-    resources[0].version.should == '1.1'
-    resources[0].content.should == 'Foo'
+      expect(resources[1].version).to eq('1.1')
+      expect(resources[1].content).to eq('two')
+    end
 
-    resources[1].version.should == '1.1'
-    resources[1].content.should == 'Bar'
+    after { subject.destroy }
   end
 
-  it "should allow querying the latest revision" do
-    resource = subject.all(:content => 'Foo').latest
+  describe ".latest" do
+    subject { model }
+
+    before do
+      subject.create(
+        :version => '1.0',
+        :content => 'foo'
+      )
+
+      subject.create(
+        :version => '1.5',
+        :content => 'foo'
+      )
+
+      subject.create(
+        :version => '1.1',
+        :content => 'foo'
+      )
+    end
+
+    it "should allow querying the latest revision" do
+      resource = subject.all(:content => 'foo').latest
 
-    resource.version.should == '1.2'
+      expect(resource.version).to eq('1.5')
+    end
   end
 end

data/spec/model/model_spec.rb

@@ -1,74 +1,98 @@
 require 'spec_helper'
-require 'model/models/basic_model'
-require 'model/models/custom_model'
+require 'model/models/base_model'
+require 'model/models/inherited_model'
 
 require 'ronin/model/model'
 
 describe Model do
-  subject { BasicModel }
+  let(:base_model) { BaseModel }
+  let(:inherited_model) { InheritedModel }
 
-  let(:custom_model) { CustomModel }
+  describe ".included" do
+    subject { base_model }
 
-  before(:all) { subject.auto_migrate! }
-
-  it "should have a default repository name" do
-    subject.default_repository_name.should == :default
+    it "should have a default repository name" do
+      expect(subject.default_repository_name).to eq(:default)
+    end
   end
 
-  it "should allow creating new instances of the model" do
-    resource = subject.new(:name => 'joe')
+  describe ".new" do
+    subject { base_model }
 
-    resource.name.should == 'joe'
-  end
+    it "should allow creating new instances of the model" do
+      resource = subject.new(:name => 'joe')
+
+      expect(resource.name).to eq('joe')
+    end
+
+    context "when the model defines an initialize method" do
+      subject { inherited_model }
 
-  it "should call initialize when creating new instances of the model" do
-    resource = custom_model.new(:name => 'joe')
+      it "should call initialize when creating new instances of the model" do
+        resource = subject.new(:name => 'joe')
 
-    resource.name.should == 'joe'
-    resource.var.should == 2
+        expect(resource.name).to eq('joe')
+        expect(resource.var).to eq(2)
+      end
+    end
   end
 
-  it "should call initialize when creating a new resource" do
-    resource = custom_model.create!(:name => 'jim')
+  describe ".create!" do
+    subject { inherited_model }
+
+    it "should call initialize when creating a new resource" do
+      resource = subject.create!(:name => 'jim')
 
-    resource.name.should == 'jim'
-    resource.var.should == 2
+      expect(resource.name).to eq('jim')
+      expect(resource.var).to eq(2)
+
+      resource.destroy
+    end
   end
 
-  it "should call initialize when loading from the database" do
-    custom_model.create!(:name => 'bob')
+  describe ".first" do
+    subject { inherited_model }
+
+    before { subject.create!(:name => 'bob') }
+
+    it "should call initialize when loading from the database" do
+      resource = subject.first(:name => 'bob')
 
-    resource = custom_model.first(:name => 'bob')
-    resource.name.should == 'bob'
-    resource.var.should == 2
+      expect(resource.name).to eq('bob')
+      expect(resource.var).to eq(2)
+    end
+
+    after { subject.destroy }
   end
 
-  describe "humanize_attributes" do
-    let(:resource) { subject.new(:name => 'joe', :age => 21) }
+  describe "#humanize_attributes" do
+    let(:model) { base_model }
+
+    subject { model.new(:name => 'joe', :age => 21) }
 
     it "should humanize the attributes of a model" do
-      resource.humanize_attributes.should == {
+      expect(subject.humanize_attributes).to be == {
         'Name' => 'joe',
         'Age' => '21'
       }
     end
 
     it "should exclude certain attributes to humanize" do
-      resource.humanize_attributes(:exclude => [:name]).should == {
+      expect(subject.humanize_attributes(:exclude => [:name])).to be == {
         'Age' => '21'
       }
     end
 
     it "should filter out nil values" do
-      resource.age = nil
+      subject.age = nil
 
-      resource.humanize_attributes.should == {'Name' => 'joe'}
+      expect(subject.humanize_attributes).to be == {'Name' => 'joe'}
     end
 
     it "should filter out empty values" do
-      resource.name = ''
+      subject.name = ''
 
-      resource.humanize_attributes.should == {'Age' => '21'}
+      expect(subject.humanize_attributes).to be == {'Age' => '21'}
     end
   end
 end

data/spec/model/models/{basic_model.rb → base_model.rb}

@@ -1,6 +1,6 @@
 require 'ronin/model/model'
 
-class BasicModel
+class BaseModel
 
   include Ronin::Model
 

data/spec/model/models/{custom_model.rb → inherited_model.rb}

@@ -1,8 +1,7 @@
 require 'ronin/model/model'
+require_relative 'base_model'
 
-require 'model/models/basic_model'
-
-class CustomModel < BasicModel
+class InheritedModel < BaseModel
 
   include Ronin::Model
 

data/spec/os_spec.rb

@@ -1,44 +1,48 @@
 require 'spec_helper'
+
 require 'ronin/os'
 
 describe OS do
-  subject do
-    OS.new(:name => 'Linux', :version => '2.6.11')
-  end
+  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 OSes" do
-      os = OS.linux
+    it "should provide methods for built-in described_classes" do
+      os = described_class.linux
 
-      os.name.should == 'Linux'
+      expect(os.name).to eq('Linux')
     end
 
-    it "should provide methods for creating OSes with versions" do
-      os = OS.linux('2.6.11')
+    it "should provide methods for creating described_classes with versions" do
+      os = described_class.linux(version)
 
-      os.version.should == '2.6.11'
+      expect(os.version).to eq(version)
     end
   end
 
-  it "should require a name" do
-    os = OS.new
-    os.should_not be_valid
+  describe "validations" do
+    it "should require a name" do
+      os = described_class.new
+      expect(os).not_to be_valid
 
-    os.name = 'test'
-    os.should 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
-      os = OS.new(:name => 'Linux', :version => '2.6.23')
-
-      os.to_s.should == 'Linux 2.6.23'
+      expect(subject.to_s).to eq("#{name} #{version}")
     end
 
-    it "should convert just the name if there is no version" do
-      os = OS.new(:name => 'Linux')
+    context "without a version" do
+      subject { described_class.new(:name => name) }
 
-      os.to_s.should == os.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,14 +1,20 @@
 require 'spec_helper'
+
 require 'ronin/password'
 
 describe Password do
   let(:password) { 'secret' }
-  subject { Password.new(:clear_text => password) }
 
-  it "should require a clear-text password" do
-    pass = Password.new
+  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.should_not be_valid
+      pass.clear_text = password
+      expect(pass).to be_valid
+    end
   end
 
   describe "#digest" do
@@ -17,23 +23,25 @@ describe Password do
     it "should calculate the digest of the password" do
       digest = subject.digest(:sha1)
       
-      digest.should == Digest::SHA1.hexdigest(password)
+      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)
       
-      digest.should == Digest::SHA1.hexdigest(salt + password)
+      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)
       
-      digest.should == Digest::SHA1.hexdigest(password + salt)
+      expect(digest).to eq(Digest::SHA1.hexdigest(password + salt))
     end
   end
 
-  it "should be convertable to a String" do
-    subject.to_s.should == password
+  describe "#to_s" do
+    it "should include the password" do
+      expect(subject.to_s).to eq(password)
+    end
   end
 end