ardm 0.0.1 → 0.1.0

data/spec/integration/api_key_spec.rb

@@ -9,17 +9,17 @@ try_spec do
     let(:original_api_key) { subject.api_key }
 
     it "should have a default value" do
-      original_api_key.should_not be_nil
+      expect(original_api_key).not_to be_nil
     end
 
     it "should preserve the default value" do
-      subject.api_key.should == original_api_key
+      expect(subject.api_key).to eq(original_api_key)
     end
 
     it "should generate unique API Keys for each resource" do
       other_resource = described_class.new(:name => 'eve')
 
-      other_resource.api_key.should_not == original_api_key
+      expect(other_resource.api_key).not_to eq(original_api_key)
     end
   end
 end

data/spec/integration/bcrypt_hash_spec.rb

@@ -14,8 +14,8 @@ try_spec do
     end
 
     it 'persists the password on initial save' do
-      @resource.password.should       == 'Ardm R0cks!'
-      @people.last.password.should == 'password1'
+      expect(@resource.password).to       eq('Ardm R0cks!')
+      expect(@people.last.password).to eq('password1')
     end
 
     it 'recalculates password hash on attribute update' do
@@ -23,23 +23,23 @@ try_spec do
       @resource.save
 
       @resource.reload
-      @resource.password.should     == 'bcryptic obscure'
-      @resource.password.should_not == 'Ardm R0cks!'
+      expect(@resource.password).to     eq('bcryptic obscure')
+      expect(@resource.password).not_to eq('Ardm R0cks!')
     end
 
     it 'does not change password value on reload' do
       resource = @people.last
       original = resource.password.to_s
       resource.reload
-      resource.password.to_s.should == original
+      expect(resource.password.to_s).to eq(original)
     end
 
     it 'uses cost of BCrypt::Engine::DEFAULT_COST' do
-      @resource.password.cost.should == BCrypt::Engine::DEFAULT_COST
+      expect(@resource.password.cost).to eq(BCrypt::Engine::DEFAULT_COST)
     end
 
     it 'allows Bcrypt::Password#hash to be an Integer' do
-      @resource.password.hash.should be_kind_of(Integer)
+      expect(@resource.password.hash).to be_kind_of(Integer)
     end
   end
 end

data/spec/integration/comma_separated_list_spec.rb

@@ -16,12 +16,12 @@ try_spec do
 
       describe 'when dumped and loaded again' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'has no interests' do
-          @resource.interests.should == nil
+          expect(@resource.interests).to eq(nil)
         end
       end
     end
@@ -33,22 +33,22 @@ try_spec do
 
       describe 'when dumped and loaded again' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'has empty interests list' do
-          @resource.interests.should == []
+          expect(@resource.interests).to eq([])
         end
       end
     end
 
     describe 'with interests information given as a Hash' do
       it 'raises ArgumentError' do
-        lambda do
+        expect do
           @resource.interests = { :hash => 'value' }
           @resource.save
-        end.should raise_error(ArgumentError, /must be a string, an array or nil/)
+        end.to raise_error(ArgumentError, /must be a string, an array or nil/)
       end
     end
 
@@ -60,24 +60,24 @@ try_spec do
 
       describe 'when dumped and loaded again' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'includes "fire" in interests' do
-          @resource.interests.should include('fire')
+          expect(@resource.interests).to include('fire')
         end
 
         it 'includes "water" in interests' do
-          @resource.interests.should include('water')
+          expect(@resource.interests).to include('water')
         end
 
         it 'includes "a whole lot of other interesting things" in interests' do
-          @resource.interests.should include('a whole lot of other interesting things')
+          expect(@resource.interests).to include('a whole lot of other interesting things')
         end
 
         it 'has blank entries removed' do
-          @resource.interests.any? { |i| Ardm::Ext.blank?(i) }.should be_false
+          expect(@resource.interests.any? { |i| Ardm::Ext.blank?(i) }).to be false
         end
       end
     end

data/spec/integration/dirty_minder_spec.rb

@@ -29,53 +29,45 @@ try_spec do
         }
         @resource.save!
         @resource.reload
-        @resource.positions['title'].should == 'Layperson'
+        expect(@resource.positions['title']).to eq('Layperson')
       end
 
       describe "when I change positions" do
         before :each do
-          @resource.changed?.should == false
+          expect(@resource.changed?).to eq(false)
           @resource.positions['title'] = 'Chief Layer of People'
           @resource.save!
           @resource.reload
         end
 
         it "should remember the new position" do
-          @resource.positions['title'].should == 'Chief Layer of People'
+          expect(@resource.positions['title']).to eq('Chief Layer of People')
         end
       end
 
       describe "when I add a new attribute of the position" do
         before :each do
-          @resource.changed?.should == false
+          expect(@resource.changed?).to eq(false)
           @resource.positions['pays_buttloads_of_money'] = true
           @resource.save!
           @resource.reload
         end
 
         it "should remember the new attribute" do
-          @resource.positions['pays_buttloads_of_money'].should be_true
+          expect(@resource.positions['pays_buttloads_of_money']).to be true
         end
       end
 
       describe "when I change the details of the position" do
         before :each do
-          @resource.changed?.should == false
+          expect(@resource.changed?).to eq(false)
           @resource.positions['details'].merge!('awesome' => "VERY TRUE")
           @resource.save!
           @resource.reload
         end
 
         it "should remember the changed detail" do
-          # Works in active record (unless something is fooling me)
-          #pending "not supported (YET)" do
-            # TODO: Not supported (yet?) -- this is a much harder problem to
-            # solve: using mutating accessors of nested objects.  We could
-            # detect it from #dirty? (using the #hash method), but #dirty?
-            # only returns the status of known-mutated properties (not full,
-            # on-demand scan of object dirty-ness).
-            @resource.positions['details']['awesome'].should == 'VERY TRUE'
-          #end
+          expect(@resource.positions['details']['awesome']).to eq('VERY TRUE')
         end
       end
 
@@ -86,8 +78,8 @@ try_spec do
         end
 
         it "should reflect the previously set/persisted value" do
-          @resource.positions.should_not be_nil
-          @resource.positions['title'].should == 'Layperson'
+          expect(@resource.positions).not_to be_nil
+          expect(@resource.positions['title']).to eq('Layperson')
         end
       end
 
@@ -103,25 +95,25 @@ try_spec do
         ]
         @resource.save!
         @resource.reload
-        @resource.positions.first['title'].should == 'Layperson'
+        expect(@resource.positions.first['title']).to eq('Layperson')
       end
 
       describe "when I remove the position" do
         before :each do
-          @resource.changed?.should == false
+          expect(@resource.changed?).to eq(false)
           @resource.positions.pop
           @resource.save!
           @resource.reload
         end
 
         it "should know there aren't any positions" do
-          @resource.positions.should == []
+          expect(@resource.positions).to eq([])
         end
       end
 
       describe "when I add a new position" do
         before :each do
-          @resource.changed?.should == false
+          expect(@resource.changed?).to eq(false)
           @resource.positions << {
             'company' => "Down and Dirty, LP",
             'title'   => "Porn Star",
@@ -132,12 +124,12 @@ try_spec do
         end
 
         it "should know there's two positions" do
-          @resource.positions.length.should == 2
+          expect(@resource.positions.length).to eq(2)
         end
 
         it "should know which position is which" do
-          @resource.positions.first['title'].should == "Layperson"
-          @resource.positions.last['title'].should == "Porn Star"
+          expect(@resource.positions.first['title']).to eq("Layperson")
+          expect(@resource.positions.last['title']).to eq("Porn Star")
         end
 
         describe "when I change the details of one of the positions" do
@@ -148,35 +140,27 @@ try_spec do
           end
 
           it "should remember the changed detail" do
-            # Works in active record (unless something is fooling me)
-            #pending "not supported (YET)" do
-              # TODO: Not supported (yet?) -- this is a much harder problem to
-              # solve: using mutating accessors of nested objects.  We could
-              # detect it from #dirty? (using the #hash method), but #dirty?
-              # only returns the status of known-mutated properties (not full,
-              # on-demand scan of object dirty-ness).
-              @resource.positions.last['details']['high_risk'].should == true
-            #end
+            expect(@resource.positions.last['details']['high_risk']).to eq(true)
           end
         end
       end # when I add a new position
 
       describe "when I remove the position with a block-based mutator" do
         before :each do
-          @resource.changed?.should == false
+          expect(@resource.changed?).to eq(false)
           @resource.positions.reject! { |_| true }
           @resource.save!
           @resource.reload
         end
 
         it "should know there aren't any positions" do
-          @resource.positions.should == []
+          expect(@resource.positions).to eq([])
         end
       end
 
       describe "when I mutate positions through a reference" do
         before :each do
-          @resource.changed?.should == false
+          expect(@resource.changed?).to eq(false)
           @positions = @resource.positions
           @positions << {
             'company' => "Ooga Booga, Inc",
@@ -185,9 +169,9 @@ try_spec do
         end
 
         it "should reflect the change in both the property and the reference" do
-          @resource.positions.length.should == 2
-          @resource.positions.last['title'].should == 'Rocker'
-          @positions.last['title'].should == 'Rocker'
+          expect(@resource.positions.length).to eq(2)
+          expect(@resource.positions.last['title']).to eq('Rocker')
+          expect(@positions.last['title']).to eq('Rocker')
         end
       end
 

data/spec/integration/enum_spec.rb

@@ -14,12 +14,12 @@ try_spec do
           :status => 'confirmed'
         )
 
-        @resource.save.should be_true
+        expect(@resource.save).to be true
         @resource.reload
       end
 
       it 'preserves property value' do
-        @resource.status.should == :confirmed
+        expect(@resource.status).to eq(:confirmed)
       end
     end
 
@@ -29,7 +29,7 @@ try_spec do
       end
 
       it 'typecasts it for outside reader' do
-        @resource.status.should == :assigned
+        expect(@resource.status).to eq(:assigned)
       end
     end
 
@@ -41,17 +41,17 @@ try_spec do
           :body   => "Note that at the very least, there should be a check to see whether or not the user is created before chown'ing a file to the user.",
           :status => 'confirmed'
         )
-        @resource.save.should be_true
+        expect(@resource.save).to be true
       end
 
       it 'supports queries with equality operator on enumeration property' do
-        Ardm::Fixtures::Ticket.where(:status => :confirmed).
-          should include(@resource)
+        expect(Ardm::Fixtures::Ticket.where(:status => :confirmed)).
+          to include(@resource)
       end
 
       it 'supports queries with inequality operator on enumeration property' do
-        Ardm::Fixtures::Ticket.where.not(:status => :confirmed).
-          should_not include(@resource)
+        expect(Ardm::Fixtures::Ticket.where(:status.not => :confirmed)).
+          not_to include(@resource)
       end
     end
 
@@ -64,15 +64,15 @@ try_spec do
       # TODO: consider sharing shared spec exampels with dm-validations,
       #       which has 'invalid model' shared group
       it 'is invalid (auto validation for :within kicks in)' do
-        @resource.should_not be_valid
+        expect(@resource).not_to be_valid
       end
 
       it 'has errors' do
-        @resource.errors.should_not be_empty
+        expect(@resource.errors).not_to be_empty
       end
 
       it 'has a meaningful error message on invalid property' do
-        @resource.errors[:status].should include('must be one of unconfirmed, confirmed, assigned, resolved, not_applicable')
+        expect(@resource.errors[:status]).to include('must be one of unconfirmed, confirmed, assigned, resolved, not_applicable')
       end
     end
   end

data/spec/integration/epoch_time_spec.rb

@@ -16,18 +16,18 @@ try_spec do
 
       describe 'after typecasting string input' do
         it 'has a valid birthday' do
-          @resource.birthday.should == ::Time.parse('1983-05-03')
+          expect(@resource.birthday).to eq(::Time.parse('1983-05-03'))
         end
       end
 
       describe 'when dumped and loaded again' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'has a valid birthday' do
-          @resource.birthday.should == ::Time.parse('1983-05-03')
+          expect(@resource.birthday).to eq(::Time.parse('1983-05-03'))
         end
       end
     end
@@ -39,18 +39,18 @@ try_spec do
 
       describe 'after typecasting nil' do
         it 'has a nil value for birthday' do
-          @resource.birthday.should be_nil
+          expect(@resource.birthday).to be_nil
         end
       end
 
       describe 'when dumped and loaded again' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'has a nil value for birthday' do
-          @resource.birthday.should be_nil
+          expect(@resource.birthday).to be_nil
         end
       end
     end

data/spec/integration/file_path_spec.rb

@@ -16,31 +16,31 @@ try_spec do
         end
 
         it 'points to original path' do
-          @resource.source_path.to_s.should == @source_path
+          expect(@resource.source_path.to_s).to eq(@source_path)
         end
 
         it 'responds to :directory?' do
-          @resource.source_path.should respond_to(:directory?)
+          expect(@resource.source_path).to respond_to(:directory?)
         end
 
         it 'responds to :file?' do
-          @resource.source_path.should respond_to(:file?)
+          expect(@resource.source_path).to respond_to(:file?)
         end
 
         it 'responds to :dirname' do
-          @resource.source_path.should respond_to(:dirname)
+          expect(@resource.source_path).to respond_to(:dirname)
         end
 
         it 'responds to :absolute?' do
-          @resource.source_path.should respond_to(:absolute?)
+          expect(@resource.source_path).to respond_to(:absolute?)
         end
 
         it 'responds to :readable?' do
-          @resource.source_path.should respond_to(:readable?)
+          expect(@resource.source_path).to respond_to(:readable?)
         end
 
         it 'responds to :size' do
-          @resource.source_path.should respond_to(:size)
+          expect(@resource.source_path).to respond_to(:size)
         end
       end
     end
@@ -53,36 +53,36 @@ try_spec do
 
       describe 'when saved and reloaded' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'points to original path' do
-          @resource.destination_path.to_s.should == @destination_path
+          expect(@resource.destination_path.to_s).to eq(@destination_path)
         end
 
         it 'responds to :directory?' do
-          @resource.destination_path.should respond_to(:directory?)
+          expect(@resource.destination_path).to respond_to(:directory?)
         end
 
         it 'responds to :file?' do
-          @resource.destination_path.should respond_to(:file?)
+          expect(@resource.destination_path).to respond_to(:file?)
         end
 
         it 'responds to :dirname' do
-          @resource.destination_path.should respond_to(:dirname)
+          expect(@resource.destination_path).to respond_to(:dirname)
         end
 
         it 'responds to :absolute?' do
-          @resource.destination_path.should respond_to(:absolute?)
+          expect(@resource.destination_path).to respond_to(:absolute?)
         end
 
         it 'responds to :readable?' do
-          @resource.destination_path.should respond_to(:readable?)
+          expect(@resource.destination_path).to respond_to(:readable?)
         end
 
         it 'responds to :size' do
-          @resource.destination_path.should respond_to(:size)
+          expect(@resource.destination_path).to respond_to(:size)
         end
       end
     end
@@ -95,12 +95,12 @@ try_spec do
 
       describe 'when saved and reloaded' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'has nil source path' do
-          @resource.source_path.should be_nil
+          expect(@resource.source_path).to be_nil
         end
       end
     end
@@ -113,12 +113,12 @@ try_spec do
 
       describe 'when saved and reloaded' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'has nil source path' do
-          @resource.source_path.should be_nil
+          expect(@resource.source_path).to be_nil
         end
       end
     end
@@ -131,12 +131,12 @@ try_spec do
 
       describe 'when saved and reloaded' do
         before do
-          @resource.save.should be_true
+          expect(@resource.save).to be true
           @resource.reload
         end
 
         it 'has nil source path' do
-          @resource.source_path.should be_nil
+          expect(@resource.source_path).to be_nil
         end
       end
     end
@@ -148,9 +148,9 @@ try_spec do
 
       describe 'when instantiated' do
         it 'raises an exception' do
-          lambda do
+          expect do
             Ardm::Fixtures::SoftwarePackage.new(:source_path => @source_path)
-          end.should raise_error(TypeError)
+          end.to raise_error(TypeError)
         end
       end
     end