ronin 1.0.0 → 1.1.0.rc1

data/spec/{engine/classes/engine_class.rb → script/classes/script_class.rb}

@@ -1,8 +1,8 @@
-require 'ronin/engine'
+require 'ronin/script'
 
-class EngineClass
+class ScriptClass
 
-  include Ronin::Engine
+  include Ronin::Script
 
   property :id, Serial
 

data/spec/{engine/classes/verifiable_class.rb → script/classes/testable_class.rb}

@@ -1,10 +1,10 @@
-require 'ronin/engine'
-require 'ronin/engine/verifiable'
+require 'ronin/script'
+require 'ronin/script/testable'
 
-class VerifiableClass
+class TestableClass
 
-  include Ronin::Engine
-  include Ronin::Engine::Verifiable
+  include Ronin::Script
+  include Ronin::Script::Testable
 
   property :id, Serial
 

data/spec/{engine → script}/deployable_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
-require 'engine/classes/deployable_class'
+require 'script/classes/deployable_class'
 
-describe Engine::Deployable do
+describe Script::Deployable do
   subject do
     obj = DeployableClass.new
     obj.instance_eval do
-      verify do
+      test do
         unless @var > 0
-          raise "engine failed verification"
+          raise "script failed verification"
         end
       end
     end
@@ -15,8 +15,8 @@ describe Engine::Deployable do
     obj
   end
 
-  it "should include Verifiable" do
-    subject.class.included_modules.should include(Engine::Verifiable)
+  it "should include Testable" do
+    subject.class.included_modules.should include(Script::Testable)
   end
 
   it "should not be deployed by default" do
@@ -24,7 +24,7 @@ describe Engine::Deployable do
   end
 
   describe "#deploy!" do
-    it "should verify! the engine before deploying it" do
+    it "should test! the script before deploying it" do
       subject.var = -1
 
       lambda {
@@ -32,13 +32,13 @@ describe Engine::Deployable do
       }.should raise_error
     end
 
-    it "should mark the engine deployed" do
+    it "should mark the script deployed" do
       subject.deploy!
 
       subject.should be_deployed
     end
 
-    it "should not mark the engine as evacuated" do
+    it "should not mark the script as evacuated" do
       subject.deploy!
 
       subject.should_not be_evacuated
@@ -46,7 +46,7 @@ describe Engine::Deployable do
   end
 
   describe "#evacuate!" do
-    it "should mark the engine as evacuated" do
+    it "should mark the script as evacuated" do
       subject.evacuate!
 
       subject.should be_evacuated

data/spec/{cached_file_spec.rb → script/path_spec.rb}

@@ -1,24 +1,19 @@
 require 'spec_helper'
 require 'helpers/repositories'
-require 'model/models/cacheable_model'
+require 'classes/my_script'
 
-require 'ronin/cached_file'
+require 'ronin/script/path'
 
-describe CachedFile do
+describe Script::Path do
   include Helpers::Repositories
 
-  let(:test1) { repository('test1') }
-  let(:test2) { repository('test2') }
+  let(:repo) { repository('scripts') }
+  let(:script_class) { MyScript }
 
-  let(:cacheable_model) { CacheableModel }
-
-  before(:all) do
-    test1.cache_files!
-    test2.cache_files!
-  end
+  before(:all) { repo.cache_scripts! }
 
   describe "cached file" do
-    subject { test1.cached_files.first }
+    subject { repo.find_script('cached/cached.rb') }
 
     it "should be saved" do
       subject.should be_saved
@@ -45,82 +40,53 @@ describe CachedFile do
     end
 
     it "should have the model name of the cached object" do
-      subject.model_name.should == cacheable_model.name
+      subject.class_name.should == script_class.name
     end
 
     it "should have the model path of the cached object" do
-      subject.model_path.should == 'cacheable_model'
+      subject.class_path.should == 'my_script'
     end
 
     it "should be able to load the Model of the cached object" do
-      subject.cached_model.should == cacheable_model
+      subject.script_class.should == script_class
     end
 
     it "should be able to load a fresh model from the cached file" do
-      obj = subject.fresh_object
+      obj = subject.load_script
 
       obj.should_not be_nil
-      obj.class.should == cacheable_model
+      obj.class.should == script_class
     end
 
     it "should cache the loaded object along with the cached file" do
-      obj = cacheable_model.first(:cached_file => subject)
+      obj = script_class.first(:script_path => subject)
       
       obj.should_not be_nil
     end
 
     it "should be able to load the cached object" do
-      subject.cached_object.should_not be_nil
-      subject.cached_object.class.should == cacheable_model
+      subject.cached_script.should_not be_nil
+      subject.cached_script.class.should == script_class
     end
 
     it "should call the cache method before saving the new object" do
-      subject.cached_object.content.should == 'this is test one'
+      subject.cached_script.name.should == 'cached'
     end
 
     it "should delete the cached object along with the cached file" do
       subject.destroy
 
-      cacheable_model.first(:cached_file => subject).should be_nil
+      script_class.first(:script_path => subject).should be_nil
     end
   end
 
   describe "failed cached files" do
-    let(:syntax_error) do
-      test2.cached_files.find do |cached_file|
-        cached_file.path.basename == Pathname.new('syntax_errors.rb')
-      end
-    end
-
-    let(:load_error) do
-      test2.cached_files.find do |cached_file|
-        cached_file.path.basename == Pathname.new('load_errors.rb')
-      end
-    end
-
-    let(:name_error) do
-      test2.cached_files.find do |cached_file|
-        cached_file.path.basename == Pathname.new('name_errors.rb')
-      end
-    end
-
-    let(:no_method_error) do
-      test2.cached_files.find do |cached_file|
-        cached_file.path.basename == Pathname.new('no_method_errors.rb')
-      end
-    end
-
-    let(:exception) do
-      test2.cached_files.find do |cached_file|
-        cached_file.path.basename == Pathname.new('exceptions.rb')
-      end
-    end
-
-    let(:validation_error) do
-      test2.cached_files.find do |cached_file|
-        cached_file.path.basename == Pathname.new('validation_errors.rb')
-      end
-    end
+    let(:syntax_error) { repo.find_script('failures/syntax_errors.rb') }
+    let(:load_error) { repo.find_script('failures/load_errors.rb') }
+    let(:name_error) { repo.find_script('failures/name_errors.rb') }
+    let(:no_method_error) { repo.find_script('failures/no_method_errors.rb') }
+    let(:exception) { repo.find_script('failures/exceptions.rb') }
+    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
@@ -162,7 +128,7 @@ describe CachedFile do
   end
 
   describe "unmodified cached file" do
-    subject { test1.cached_files.first }
+    subject { repo.find_script('cached/unmodified.rb') }
 
     it "should not have updated code" do
       should_not be_updated
@@ -178,13 +144,10 @@ describe CachedFile do
   end
 
   describe "modified cached file" do
-    subject do
-      test1.reload
-
-      cached_file = test1.cached_files.first
-      cached_file.update(:timestamp => (cached_file.timestamp - 10))
+    subject { repo.find_script('cached/modified.rb') }
 
-      cached_file
+    before(:all) do
+      subject.update(:timestamp => (subject.timestamp - 10))
     end
 
     it "should not have updated code" do
@@ -201,22 +164,20 @@ describe CachedFile do
   end
 
   describe "missing cached file" do
-    subject do
-      test1.reload
+    subject { repo.find_script('cached/missing.rb') }
 
-      cached_file = test1.cached_files.first
-      cached_file.update(:path => File.join('','missing','file.rb'))
-      cached_file.sync
+    before(:all) do
+      subject.update(:path => File.join('','missing','file.rb'))
 
-      cached_file
+      subject.sync
     end
 
     it "should delete the cached files" do
-      CachedFile.count(:id => subject.id).should == 0
+      described_class.count(:id => subject.id).should == 0
     end
 
     it "should delete cached objects for missing files" do
-      cacheable_model.count(:cached_file => subject).should == 0
+      script_class.count(:script_path => subject).should == 0
     end
   end
 end

data/spec/script/script_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'classes/my_script'
+require 'helpers/repositories'
+
+require 'ronin/script'
+
+describe Script do
+  include Helpers::Repositories
+
+  subject { MyScript }
+
+  let(:repo) { repository('scripts') }
+
+  before(:all) { repo.cache_scripts! }
+
+  it "should be a Model" do
+    subject.included_modules.should include(Model)
+  end
+
+  it "should have a name" do
+    subject.included_modules.should include(Model::HasName)
+  end
+
+  it "should have a description" do
+    subject.included_modules.should include(Model::HasDescription)
+  end
+
+  it "should have a version" do
+    subject.included_modules.should include(Model::HasVersion)
+  end
+
+  it "should include ObjectLoader" do
+    subject.included_modules.should include(ObjectLoader)
+  end
+
+  it "should include DataPaths::Finders" do
+    subject.included_modules.should include(DataPaths::Finders)
+  end
+
+  it "should include Parameters" do
+    subject.included_modules.should include(Parameters)
+  end
+
+  it "should include UI::Output::Helpers" do
+    subject.included_modules.should include(UI::Output::Helpers)
+  end
+
+  it "should add the type property to the model" do
+    subject.properties.should be_named(:type)
+  end
+
+  it "should add a relation between Script::Path and the script" do
+    subject.relationships.should be_named(:script_path)
+  end
+
+  describe "#initialize" do
+    it "should initialize attributes" do
+      resource = subject.new(:name => 'test')
+
+      resource.name.should == 'test'
+    end
+
+    it "should initialize parameters" do
+      resource = subject.new(:x => 5)
+
+      resource.x.should == 5
+    end
+
+    it "should allow custom initialize methods" do
+      resource = subject.new
+
+      resource.var.should == 2
+    end
+  end
+
+  it "should have an script-type" do
+    resource = subject.new
+
+    resource.script_type.should == 'MyScript'
+  end
+
+  describe "load_from" do
+    let(:path) { repo.find_script('my_scripts/test.rb').path }
+
+    subject { Script.load_from(path) }
+
+    it "should have a script_path resource" do
+      subject.script_path.should_not be_nil
+    end
+
+    it "should prepare the object to be cached" do
+      subject.content.should == 'this is a test'
+    end
+
+    it "should preserve instance variables" do
+      subject.var.should == 2
+    end
+
+    it "should preserve instance methods" do
+      subject.greeting.should == 'hello'
+    end
+
+    it "should load the script source" do
+      subject.should be_script_loaded
+    end
+  end
+
+  context "when previously cached" do
+    subject { MyScript.first(:name => 'test') }
+
+    it "should have a cached_file resource" do
+      subject.script_path.should_not be_nil
+    end
+
+    it "should be able to load the script source" do
+      subject.load_script!
+
+      subject.greeting.should == 'hello'
+    end
+
+    it "should only load the script source once" do
+      subject.load_script!
+
+      subject.var = false
+      subject.load_script!
+
+      subject.var.should == false
+    end
+  end
+end

data/spec/script/testable_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'ronin/script/testable'
+require 'script/classes/testable_class'
+
+describe Script::Testable do
+  subject { TestableClass }
+
+  it "should allow for custom verifications" do
+    obj = subject.new do
+      test do
+        flunk('var must be greater than 2') unless self.var > 2
+      end
+
+      test do
+        flunk('var must be less than 10') unless self.var < 10
+      end
+    end
+
+    obj.var = 20
+    lambda { obj.test! }.should raise_error(Script::TestFailed)
+
+    obj.var = 4
+    obj.test!.should == true
+  end
+
+  it "should test an expression is true" do
+    obj = subject.new do
+      test? 'var + 2 must equal 4' do
+        (self.var + 2) == 4
+      end
+    end
+
+    obj.var = 1
+    lambda { obj.test! }.should raise_error(Script::TestFailed)
+
+    obj.var = 2
+    obj.test!.should == 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)
+
+    obj.var = 5
+    obj.test!.should == 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)
+
+    obj.var = 2
+    obj.test!.should == 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)
+
+    obj.var = 2
+    obj.test!.should == 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)
+
+    obj.var = 'hello'
+    obj.test!.should == 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)
+
+    obj.var = 'hello'
+    obj.test!.should == 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)
+
+    obj.var = 'goodbye'
+    obj.test!.should == 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)
+
+    obj.var = 2
+    obj.test!.should == 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)
+
+    obj.var = 3
+    obj.test!.should == true
+  end
+end