ronin 1.5.0 → 1.5.1

data/spec/script/path_spec.rb

@@ -10,73 +10,73 @@ describe Script::Path do
   let(:repo) { repository('scripts') }
   let(:script_class) { MyScript }
 
-  before(:all) { repo.cache_scripts! }
+  before { repo.cache_scripts! }
 
   describe "cached file" do
     subject { repo.find_script('cached/cached.rb') }
 
     it "should be saved" do
-      subject.should be_saved
+      expect(subject).to be_saved
     end
 
     it "should have a path" do
-      subject.path.should_not be_nil
+      expect(subject.path).not_to be_nil
     end
 
     it "should have a timestamp" do
-      subject.timestamp.should_not be_nil
+      expect(subject.timestamp).not_to be_nil
     end
 
     it "should not have updated code" do
-      subject.should_not be_updated
+      expect(subject).not_to be_updated
     end
 
     it "should not have cache exceptions" do
-      subject.cache_exception.should be_nil
+      expect(subject.cache_exception).to be_nil
     end
 
     it "should not have cache errors" do
-      subject.cache_errors.should be_nil
+      expect(subject.cache_errors).to be_nil
     end
 
     it "should have the model name of the cached object" do
-      subject.class_name.should == script_class.name
+      expect(subject.class_name).to eq(script_class.name)
     end
 
     it "should have the model path of the cached object" do
-      subject.class_path.should == 'my_script'
+      expect(subject.class_path).to eq('my_script')
     end
 
     it "should be able to load the Model of the cached object" do
-      subject.script_class.should == script_class
+      expect(subject.script_class).to eq(script_class)
     end
 
     it "should be able to load a fresh model from the cached file" do
       obj = subject.load_script
 
-      obj.should_not be_nil
-      obj.class.should == script_class
+      expect(obj).not_to be_nil
+      expect(obj.class).to eq(script_class)
     end
 
     it "should cache the loaded object along with the cached file" do
       obj = script_class.first(:script_path => subject)
       
-      obj.should_not be_nil
+      expect(obj).not_to be_nil
     end
 
     it "should be able to load the cached object" do
-      subject.cached_script.should_not be_nil
-      subject.cached_script.class.should == script_class
+      expect(subject.cached_script).not_to be_nil
+      expect(subject.cached_script.class).to eq(script_class)
     end
 
     it "should call the cache method before saving the new object" do
-      subject.cached_script.name.should == 'cached'
+      expect(subject.cached_script.name).to eq('cached')
     end
 
     it "should delete the cached object along with the cached file" do
       subject.destroy
 
-      script_class.first(:script_path => subject).should be_nil
+      expect(script_class.first(:script_path => subject)).to be_nil
     end
   end
 
@@ -89,41 +89,43 @@ describe Script::Path do
     let(:validation_error) { repo.find_script('failures/validation_errors.rb') }
 
     it "should not save new cached files that raised exceptions" do
-      syntax_error.should_not be_saved
-      load_error.should_not be_saved
-      exception.should_not be_saved
+      expect(syntax_error).not_to be_saved
+      expect(load_error).not_to be_saved
+      expect(exception).not_to be_saved
     end
 
-    it "should not save new cached files that contain validation errors" do
-      validation_error.should_not be_saved
+    pending "https://github.com/ronin-rb/ronin/issues/7" do
+      it "should not save new cached files that contain validation errors" do
+        expect(validation_error).to_not be_saved
+      end
     end
 
     it "should store syntax errors" do
-      syntax_error.cache_exception.should_not be_nil
-      syntax_error.cache_exception.class.should == SyntaxError
+      expect(syntax_error.cache_exception).not_to be_nil
+      expect(syntax_error.cache_exception.class).to eq(SyntaxError)
     end
 
     it "should store LoadError exceptions" do
-      load_error.cache_exception.should_not be_nil
-      load_error.cache_exception.class.should == LoadError
+      expect(load_error.cache_exception).not_to be_nil
+      expect(load_error.cache_exception.class).to eq(LoadError)
     end
 
     it "should store NameError exceptions" do
-      name_error.cache_exception.should_not be_nil
-      name_error.cache_exception.class.should == NameError
+      expect(name_error.cache_exception).not_to be_nil
+      expect(name_error.cache_exception.class).to eq(NameError)
     end
 
     it "should store NoMethodError exceptions" do
-      no_method_error.cache_exception.should_not be_nil
-      no_method_error.cache_exception.class.should == NoMethodError
+      expect(no_method_error.cache_exception).not_to be_nil
+      expect(no_method_error.cache_exception.class).to eq(NoMethodError)
     end
 
     it "should store Exceptions raised when creating the fresh object" do
-      exception.cache_exception.should_not be_nil
+      expect(exception.cache_exception).not_to be_nil
     end
 
     it "should store validation errors" do
-      validation_error.cache_errors.should_not be_nil
+      expect(validation_error.cache_errors).not_to be_nil
     end
   end
 
@@ -135,18 +137,18 @@ describe Script::Path do
     end
 
     it "should not re-cache unmodified files" do
-      subject.sync.should == false
+      expect(subject.sync).to be(false)
     end
 
     it "should not have cache errors" do
-      subject.cache_errors.should be_nil
+      expect(subject.cache_errors).to be_nil
     end
   end
 
   describe "modified cached file" do
     subject { repo.find_script('cached/modified.rb') }
 
-    before(:all) do
+    before do
       subject.update(:timestamp => (subject.timestamp - 10))
     end
 
@@ -155,29 +157,29 @@ describe Script::Path do
     end
 
     it "should re-cache modified files" do
-      subject.sync.should == true
+      expect(subject.sync).to be(true)
     end
 
     it "should not have cache errors" do
-      subject.cache_errors.should be_nil
+      expect(subject.cache_errors).to be_nil
     end
   end
 
   describe "missing cached file" do
     subject { repo.find_script('cached/missing.rb') }
 
-    before(:all) do
+    before do
       subject.update(:path => File.join('','missing','file.rb'))
 
       subject.sync
     end
 
     it "should delete the cached files" do
-      described_class.count(:id => subject.id).should == 0
+      expect(described_class.count(:id => subject.id)).to eq(0)
     end
 
     it "should delete cached objects for missing files" do
-      script_class.count(:script_path => subject).should == 0
+      expect(script_class.count(:script_path => subject)).to eq(0)
     end
   end
 end

data/spec/script/script_spec.rb

@@ -11,70 +11,70 @@ describe Script do
 
   let(:repo) { repository('scripts') }
 
-  before(:all) { repo.cache_scripts! }
+  before { repo.cache_scripts! }
 
   it "should be a Model" do
-    subject.included_modules.should include(Model)
+    expect(subject.included_modules).to include(Model)
   end
 
   it "should have a name" do
-    subject.included_modules.should include(Model::HasName)
+    expect(subject.included_modules).to include(Model::HasName)
   end
 
   it "should have a description" do
-    subject.included_modules.should include(Model::HasDescription)
+    expect(subject.included_modules).to include(Model::HasDescription)
   end
 
   it "should have a version" do
-    subject.included_modules.should include(Model::HasVersion)
+    expect(subject.included_modules).to include(Model::HasVersion)
   end
 
   it "should include ObjectLoader" do
-    subject.included_modules.should include(ObjectLoader)
+    expect(subject.included_modules).to include(ObjectLoader)
   end
 
   it "should include DataPaths::Finders" do
-    subject.included_modules.should include(DataPaths::Finders)
+    expect(subject.included_modules).to include(DataPaths::Finders)
   end
 
   it "should include Parameters" do
-    subject.included_modules.should include(Parameters)
+    expect(subject.included_modules).to include(Parameters)
   end
 
   it "should include UI::Output::Helpers" do
-    subject.included_modules.should include(UI::Output::Helpers)
+    expect(subject.included_modules).to include(UI::Output::Helpers)
   end
 
   it "should add the type property to the model" do
-    subject.properties.should be_named(:type)
+    expect(subject.properties).to be_named(:type)
   end
 
   it "should add a relation between Script::Path and the script" do
-    subject.relationships.should be_named(:script_path)
+    expect(subject.relationships).to be_named(:script_path)
   end
 
   describe "#initialize" do
     it "should initialize attributes" do
       resource = subject.new(:name => 'test')
 
-      resource.name.should == 'test'
+      expect(resource.name).to eq('test')
     end
 
     it "should initialize parameters" do
       resource = subject.new(:x => 5)
 
-      resource.x.should == 5
+      expect(resource.x).to eq(5)
     end
 
     it "should allow custom initialize methods" do
       resource = subject.new
 
-      resource.var.should == 2
+      expect(resource.var).to eq(2)
     end
   end
 
   it "should have an short-name" do
-    subject.short_name.should == 'MyScript'
+    expect(subject.short_name).to eq('MyScript')
   end
 
   describe "load_from" do
@@ -83,23 +83,23 @@ describe Script do
     subject { Script.load_from(path) }
 
     it "should have a script_path resource" do
-      subject.script_path.should_not be_nil
+      expect(subject.script_path).not_to be_nil
     end
 
     it "should prepare the object to be cached" do
-      subject.content.should == 'this is a test'
+      expect(subject.content).to eq('this is a test')
     end
 
     it "should preserve instance variables" do
-      subject.var.should == 2
+      expect(subject.var).to eq(2)
     end
 
     it "should preserve instance methods" do
-      subject.greeting.should == 'hello'
+      expect(subject.greeting).to eq('hello')
     end
 
     it "should load the script source" do
-      subject.should be_script_loaded
+      expect(subject).to be_script_loaded
     end
   end
 
@@ -107,13 +107,13 @@ describe Script do
     subject { MyScript.first(:name => 'test') }
 
     it "should have a cached_file resource" do
-      subject.script_path.should_not be_nil
+      expect(subject.script_path).not_to be_nil
     end
 
     it "should be able to load the script source" do
       subject.load_script!
 
-      subject.greeting.should == 'hello'
+      expect(subject.greeting).to eq('hello')
     end
 
     it "should only load the script source once" do
@@ -122,7 +122,7 @@ describe Script do
       subject.var = false
       subject.load_script!
 
-      subject.var.should == false
+      expect(subject.var).to be(false)
     end
   end
 end

data/spec/script/testable_spec.rb

@@ -17,10 +17,10 @@ describe Script::Testable do
     end
 
     obj.var = 20
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 4
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test an expression is true" do
@@ -31,87 +31,87 @@ describe Script::Testable do
     end
 
     obj.var = 1
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 2
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test a method returns an expected value" do
     obj = subject.new { test_equal :var, 5 }
 
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 5
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test a method does not return an expected value" do
     obj = subject.new { test_not_equal :var, 5 }
 
     obj.var = 5
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 2
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test a method returns a non-nil value" do
     obj = subject.new { test_set :var }
 
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 2
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test a method returns a non-empty value" do
     obj = subject.new { test_set :var }
 
     obj.var = ''
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 'hello'
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test a method matches a pattern" do
     obj = subject.new { test_match :var, /lo/ }
 
     obj.var = 'goodbye'
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 'hello'
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test a method does not match a pattern" do
     obj = subject.new { test_no_match :var, /lo/ }
 
     obj.var = 'hello'
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 'goodbye'
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test a method returns a value in a set of values" do
     obj = subject.new { test_in :var, [0, 2, 4, 8] }
 
     obj.var = 3
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 2
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 
   it "should test a method returns a value not in a set of values" do
     obj = subject.new { test_not_in :var, [0, 2, 4, 8] }
 
     obj.var = 2
-    lambda { obj.test! }.should raise_error(Script::TestFailed)
+    expect { obj.test! }.to raise_error(Script::TestFailed)
 
     obj.var = 3
-    obj.test!.should == true
+    expect(obj.test!).to be(true)
   end
 end