saper 0.5.1 → 0.5.2

data/spec/actions/find_spec.rb

@@ -1,51 +1,35 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::Find do
-  
-  let(:action) do
+  let :subject do
     Saper::Actions::Find.new("//p")
   end
-  
-  context ".new(nil)" do
-    it "raises InvalidArgument" do
-      expect { Saper::Actions::Find.new(nil) }.to raise_error(Saper::InvalidArgument)
-    end
+  let :html do
+    Saper::Items::HTML.new('<div><p>test</p><p>test</p></div>')
   end
-  
-  context ".new(CSS)" do
-    it "raises no errors" do
-      expect { Saper::Actions::Find.new("a") }.to_not raise_error
-    end
+  let :json do
+    Saper::Items::JSON.new('{"p":{"a":0},"z":{"a":1}}')
   end
-  
-  context "#run(nil)" do
-    it "raises InvalidInput" do
-      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
+  it ".new(nil) raises InvalidArgument" do
+    lambda { Saper::Actions::Find.new(nil) }.must_raise(Saper::InvalidArgument)
   end
-  
-  context "#run(HTML)" do
-    let(:input) do
-      Saper::Items::HTML.new('<div><p>test</p><p>test</p></div>')
-    end
-    it "returns an array of results" do
-      action.run(input).should be_a(Array)
-    end
-    it "returns an array with first item an HTML instance" do
-      action.run(input).first.should be_a(Saper::Items::HTML)
-    end
+  it ".new(CSS) raises no errors" do
+    lambda { Saper::Actions::Find.new("a") }.must_be_silent
   end
-  
-  context "#run(JSON)" do
-    let(:input) do
-      Saper::Items::JSON.new('{"p":{"a":0},"z":{"a":1}}')
-    end
-    it "returns an array of results" do
-      action.run(input).should be_a(Array)
-    end
-    it "returns an array with first item a JSON instance" do
-      action.run(input).first.should be_a(Saper::Items::JSON)
-    end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
+  end  
+  it "#run(HTML) returns an array of results" do
+    subject.run(html).must_be_instance_of(Array)
+  end
+  it "#run(HTML) returns an array with first item an HTML instance" do
+    subject.run(html).first.must_be_instance_of(Saper::Items::HTML)
+  end
+  it "#run(JSON) returns an array of results" do
+    subject.run(json).must_be_instance_of(Array)
+  end
+  it "#run(JSON) returns an array with first item a JSON instance" do
+    subject.run(json).first.must_be_instance_of(Saper::Items::JSON)
   end
   
 end

data/spec/actions/get_attribute_spec.rb

@@ -1,7 +1,34 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::GetAttribute do
-  
-  it # TODO
-  
+  let :subject do
+    Saper::Actions::GetAttribute.new("class")
+  end
+  let :html do
+    Saper::Items::HTML.new('<div class="ok"></div>').find("div")
+  end
+  let :xml do
+    Saper::Items::XML.new('<item class="ok"></item>').find("item")
+  end
+  it ".new(nil) raises InvalidArgument" do
+    lambda { Saper::Actions::GetAttribute.new(nil) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(String) raises no errors" do
+    lambda { Saper::Actions::GetAttribute.new("a") }.must_be_silent
+  end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(HTML) returns Text instance" do
+    subject.run(html).must_be_instance_of(Saper::Items::Text)
+  end
+  it "#run(HTML) returns valid output" do
+    subject.run(html).must_be :==, 'ok'
+  end
+  it "#run(XML) returns Text instance" do
+    subject.run(xml).must_be_instance_of(Saper::Items::Text)
+  end
+  it "#run(XML) returns valid output" do
+    subject.run(xml).must_be :==, 'ok'
+  end
 end

data/spec/actions/nothing_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::Nothing do
+  
+  it # TODO
+  
+end

data/spec/actions/prepend_with_spec.rb

@@ -1,24 +1,37 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::PrependWith do
-  
-  let(:action) do
+  let :subject do
     Saper::Action.new(:prepend_with, '!')
   end
-  
-  context ".new" do
-    it "raises InvalidArgument when argument is missing" do
-      expect { subject }.to raise_error(Saper::InvalidArgument)
-    end
-  end
-  
-  context "#run" do
-    it "raises InvalidInput when input is nil" do
-      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
-    it "returns valid output when input is Text" do
-      action.run('string').should == '!string'
-    end
-  end
-  
+  it ".new(nil) raises InvalidArgument" do
+    lambda { Saper::Actions::PrependWith.new }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(Numeric) raises InvalidArgument" do
+    lambda { Saper::Actions::PrependWith.new(2) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(Hash) raises InvalidArgumenth" do
+    lambda { Saper::Actions::PrependWith.new({}) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(Array) raises InvalidArgument" do
+    lambda { Saper::Actions::PrependWith.new([]) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(String)returns Action instance" do
+    Saper::Actions::PrependWith.new("!").must_be_kind_of(Saper::Action)
+  end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(Numeric) returns valid output" do
+    lambda { subject.run(1) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(String) returns valid output" do
+    subject.run('string').must_be :==, '!string'
+  end
+  it "#run(Text) returns valid output" do
+    subject.run(Saper::Items::Text.new('string')).must_be :==, '!string'
+  end
+  it "#run returns Text instance" do
+    subject.run('string').must_be_instance_of(Saper::Items::Text)
+  end
 end

data/spec/actions/remove_matching_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::RemoveMatching do
+  
+  it # TODO
+  
+end

data/spec/actions/remove_tags_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::RemoveTags do
+  
+  it # TODO
+  
+end

data/spec/actions/run_recipe_and_save_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::RunRecipeAndSave do
+  
+  it # TODO
+  
+end

data/spec/actions/run_recipe_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::RunRecipe do
+  
+  it # TODO
+  
+end

data/spec/arguments/attribute_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Arguments::Attribute do
+  
+  it # TODO
+  
+end

data/spec/arguments/recipe_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Arguments::Recipe do
+  
+  it # TODO
+  
+end

data/spec/arguments/text_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Arguments::Text do
+  
+  it # TODO
+  
+end

data/spec/arguments/timezone_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Arguments::Timezone do
+  
+  it # TODO
+  
+end

data/spec/arguments/variable_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Arguments::Variable do
+  
+  it # TODO
+  
+end

data/spec/arguments/xpath_spec.rb

@@ -0,0 +1,7 @@
+require './spec/spec_helper'
+
+describe Saper::Arguments::XPath do
+  
+  it # TODO
+  
+end

data/spec/core/action_spec.rb

@@ -1,151 +1,22 @@
 require './spec/spec_helper'
 
 describe Saper::Action do
-  
-  context ".[]" do
-    it "raises ActionNotFound with unrecognized type" do
-      expect { Saper::Action[:unknown] }.to raise_error(Saper::ActionNotFound)
-    end
+  it ".[] raises ActionNotFound when supplied with invalid type" do
+    lambda { Saper::Action[:unknown] }.must_raise(Saper::ActionNotFound)
   end
-  
-  context ".new with unrecognized type" do
-    it "raises ActionNotFound" do
-      expect { Saper::Action.new(:unknown) }.to raise_error(Saper::ActionNotFound)
-    end
+  it ".new raises ActionNotFound when supplied with invalid type" do
+    lambda { Saper::Action.new(:unknown) }.must_raise(Saper::ActionNotFound)
   end
-  
-  context ".accepts" do
-    it "returns an empty array" do
-      Saper::Action.accepts.should == []
-    end
+  it ".new returns Action when supplied with valid type" do
+    Saper::Action.new(:nothing).must_be_kind_of(Saper::Actions::Nothing)
   end
-  
-  context ".unserialize(Hash)" do
-    it "returns Action instance" do
-      Saper::Action.unserialize({ :type => :test_action }).should be_a(Saper::Action)
-    end
+  it ".unserialize raises InvalidAction when supplied with nil" do
+    lambda { Saper::Action.unserialize(nil) }.must_raise(Saper::InvalidAction)
   end
-  
-  context ".unserialize(Array)" do
-    it "returns an Array" do
-      Saper::Action.unserialize([{ :type => :test_action }, { :type => :test_action }]).should be_a(Array)
-    end
+  it ".unserialize returns Action when supplied with a valid Hash" do
+    Saper::Action.unserialize({ :type => :nothing }).must_be_kind_of(Saper::Action)
   end
-  
-  context ".unserialize(nil)" do
-    it "raises InvalidAction" do
-      expect { Saper::Action.unserialize(nil) }.to raise_error(Saper::InvalidAction)
-    end
+  it ".unserialize returns an Array when supplied with an Array" do
+    Saper::Action.unserialize([{ :type => :nothing }, { :type => :nothing }]).must_be_kind_of(Array)
   end
-    
-end
-
-describe TestAction do
-  
-  context ".type" do
-    it "returns underscored class name" do
-      TestAction.type.should == 'test_action'
-    end
-  end
-  
-  context ".accepts" do
-    it "returns an array of acceptable input types" do
-      TestAction.accepts.should == [:text]
-    end
-  end
-  
-  context ".[]" do
-    it "returns new class" do
-      Saper::Action[:test_action].should == TestAction
-    end
-  end
-  
-  context ".new" do
-    it "returns an instance of new class" do
-      Saper::Action.new(:test_action).should be_a(TestAction)
-    end
-  end
-  
-  context "#name" do
-    it "returns human readable name" do
-      TestAction.new.name.should == 'Test Action'
-    end
-  end
-  
-  context "#options" do
-    it "returns empty Hash by default" do
-      TestAction.new.options.should == {}
-    end
-    it "returns Hash when options are set" do
-      TestAction.new(:test => true).options.should == { :test => true }
-    end
-  end
-  
-  context "#namespace" do
-    it "returns nil by default" do
-      TestAction.new.namespace.should be_nil
-    end
-    it "returns Saper::Namespace when set" do
-      TestAction.new(:namespace => Saper::Namespace.new).namespace.should be_a(Saper::Namespace)
-    end
-  end
-  
-  context "#run with valid input" do
-    it "returns input by default" do
-      TestAction.new.run("OK").should == 'OK'
-    end
-  end
-  
-  context "#run with invalid input" do
-    it "raises InvalidInput" do
-      expect { TestAction.new.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
-  end
-  
-  context "#serialize" do
-    it "returns a Hash" do
-      TestAction.new.serialize.should be_a(Hash)
-    end
-  end
-  
-end
-
-describe ActionWithMandatoryArgument do
-  
-  context ".new" do
-    it "raises InvalidArgument when argument is missing" do
-      expect { ActionWithMandatoryArgument.new }.to raise_error(Saper::InvalidArgument)
-    end
-    it "raises no errors when argument is present" do
-      expect { ActionWithMandatoryArgument.new("text") }.to_not raise_error
-    end
-  end
-  
-  context "#run with valid input" do
-    it "returns valid output" do
-      ActionWithMandatoryArgument.new("append this").run("with that").should == 'append this with that'
-    end
-  end
-  
-  context "#run with invalid input" do
-    it "raises InvalidInput" do
-      expect { ActionWithMandatoryArgument.new("text").run(nil) }.to raise_error(Saper::InvalidInput)
-    end
-  end
-  
-end
-
-describe ActionWithOptionalArgument do
-  
-  context ".new" do
-    it "raises no errors when argument is missing" do
-      expect { ActionWithOptionalArgument.new }.to_not raise_error
-    end
-    it "raises no errors when argument is present" do
-      expect { ActionWithOptionalArgument.new("text") }.to_not raise_error
-    end
-  end
-  
-end
-
-
+end

data/spec/core/argument_spec.rb

@@ -1,79 +1,46 @@
 require './spec/spec_helper'
 
 describe Saper::Argument do
-  
-  context ".new" do
-    context "when required value is nil" do
-      it "raises InvalidArgument" do
-        expect { Saper::Argument.new(:text, :value => nil) }.to raise_error(Saper::InvalidArgument)
-      end
-    end
-    context "when required value is missing" do
-      it "raises InvalidArgument" do
-        expect { Saper::Argument.new(:text) }.to raise_error(Saper::InvalidArgument)
-      end
-    end
-    context "when required value is invalid" do
-      it "raises InvalidArgument" do
-        expect { Saper::Argument.new(:text, :value => 1) }.to raise_error(Saper::InvalidArgument)
-      end
-    end
-    context "when required value is valid" do
-      it "raises no exceptions" do
-        expect { Saper::Argument.new(:text, :value => "text") }.to_not raise_error
-      end
-    end
-    context "when optional value is missing" do
-      it "raises no exceptions" do
-        expect { Saper::Argument.new(:text, :optional => true) }.to_not raise_error
-      end
-    end
-    context "when optional value is invalid" do
-      it "raises InvalidArgument" do
-        expect { Saper::Argument.new(:text, :optional => true, :value => 1) }.to raise_error(Saper::InvalidArgument)
-      end
-    end
-    context "when optional value is valid" do
-      it "returns Action instance" do
-        expect { Saper::Argument.new(:text, :optional => true, :value => "text") }.to_not raise_error
-      end
-    end
+  it ".new raises InvalidArgument when required value is nil" do
+    lambda { Saper::Argument.new(:text, :value => nil) }.must_raise(Saper::InvalidArgument)
   end
-  
-  context "#set" do
-    context "when required value is invalid" do
-      it "raises InvalidArgument" do
-        expect { Saper::Argument.new(:text, :value => "text").set(1) }.to raise_error(Saper::InvalidArgument)
-      end
-    end
-    context "when optional value is invalid" do
-      it "raises InvalidArgument" do
-        expect { Saper::Argument.new(:text, :optional => true, :value => "text").set(1) }.to raise_error(Saper::InvalidArgument)
-      end
-    end
-    context "when value is valid" do
-      it "returns self" do
-        Saper::Argument.new(:text, :optional => true).set("text").should be_a(Saper::Argument)
-      end
-    end
+  it ".new raises InvalidArgument when required value is missing" do
+    lambda { Saper::Argument.new(:text) }.must_raise(Saper::InvalidArgument)
   end
-  
-  context "#value" do
-    it "returns nil by default" do
-      Saper::Argument.new(:text, :optional => true).value.should be_nil
-    end
-    it "returns stored value" do
-      Saper::Argument.new(:text, :value => "text").value.should == "text"
-    end
+  it ".new raises InvalidArgument when required value is invalid" do
+    lambda { Saper::Argument.new(:text, :value => 1) }.must_raise(Saper::InvalidArgument)
   end
-  
-  context "#optional?" do
-    it "returns false by default" do
-      Saper::Argument.new(:text, :value => "text").should_not be_optional
-    end
-    it "returns true if optionality flag is set" do
-      Saper::Argument.new(:text, :optional => true).should be_optional
-    end
+  it ".new raises no exceptions when required value is valid" do
+    Saper::Argument.new(:text, :value => "text").must_be_kind_of(Saper::Argument)
+  end
+  it ".new raises no exceptions when optional value is missing" do
+    Saper::Argument.new(:text, :optional => true).must_be_kind_of(Saper::Argument)
+  end
+  it ".new raises InvalidArgument when optional value is invalid" do
+    lambda { Saper::Argument.new(:text, :optional => true, :value => 1) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new returns Action instance when optional value is valid" do
+    Saper::Argument.new(:text, :optional => true, :value => "text").must_be_kind_of(Saper::Argument)
+  end
+  it "#set raises InvalidArgument when required value is invalid" do
+    lambda { Saper::Argument.new(:text, :value => "text").set(1) }.must_raise(Saper::InvalidArgument)
+  end
+  it "#set raises InvalidArgument when optional value is invalid" do
+    lambda { Saper::Argument.new(:text, :optional => true, :value => "text").set(1) }.must_raise(Saper::InvalidArgument)
+  end
+  it "#set returns self when value is valid" do
+    Saper::Argument.new(:text, :optional => true).set("text").must_be_kind_of(Saper::Argument)
+  end
+  it "#value returns nil by default" do
+    Saper::Argument.new(:text, :optional => true).value.must_be_nil
+  end
+  it "#value returns stored value" do
+    Saper::Argument.new(:text, :value => "text").value.must_equal "text"
+  end
+  it "#optional? returns false by default" do
+    Saper::Argument.new(:text, :value => "text").wont_be :optional?
+  end
+  it "#optional? returns true if optionality flag is set" do
+    Saper::Argument.new(:text, :optional => true).must_be :optional?
   end
-  
 end