saper 0.5.0

data/spec/actions/convert_to_time_spec.rb

@@ -0,0 +1,37 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::ConvertToTime do
+
+  let(:action_without_tz) do
+    Saper::Action.new(:convert_to_time, '%d-%m-%Y %H:%M')
+  end
+  
+  let(:action_with_tz) do
+    Saper::Action.new(:convert_to_time, '%d-%m-%Y %H:%M', 'Europe/Moscow')
+  end
+  
+  context ".new" do
+    it "raises InvalidArgument when argument is missing" do
+      expect { subject }.to raise_error(Saper::InvalidArgument)
+    end
+  end
+  
+  context ".accepts" do
+    it "returns acceptable input types" do
+      Saper::Actions::ConvertToTime.accepts.should == [:text]
+    end
+  end
+  
+  context "#run" do
+    it "raises InvalidInput when input is nil" do
+      expect { action_without_tz.run(nil) }.to raise_error(Saper::InvalidInput)
+    end
+    it "returns valid time when input is a valid date with timezone" do
+      action_with_tz.run('19-04-2014 18:56').should == '2014-04-19T18:56:00+04:00'
+    end
+    it "returns valid time when input is a valid date without timezone" do
+      action_without_tz.run('19-04-2014 18:56').should == '2014-04-19T18:56:00+00:00'
+    end
+  end
+  
+end

data/spec/actions/convert_to_xml_spec.rb

@@ -0,0 +1,24 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::ConvertToXML do
+  
+  let(:action) do
+    Saper::Action.new(:convert_to_xml)
+  end
+  
+  context ".accepts" do
+    it "returns acceptable input types" do
+      Saper::Actions::ConvertToXML.accepts.should == [:text, :document]
+    end
+  end
+  
+  context "#run" do
+    it "raises InvalidInput when input is nil" do
+      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
+    end
+    it "raises no errors when input is a valid Text" do
+      expect { action.run('<root>test</root>') }.to_not raise_error
+    end
+  end
+  
+end

data/spec/actions/create_atom_spec.rb

@@ -0,0 +1,31 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::CreateAtom do
+  
+  let(:action) do
+    Saper::Action.new(:create_atom)
+  end
+  
+  let(:runtime) do
+    Saper::Runtime.new
+  end
+  
+  context ".accepts" do
+    it "returns acceptable input types" do
+      Saper::Actions::CreateAtom.accepts.should == [:atom, :document, :html, :json, :markdown, :nothing, :text, :time, :url, :xml]
+    end
+  end
+  
+  context "#run" do
+    it "raises RuntimeMissing when runtime is missing" do
+      expect { action.run(nil) }.to raise_error(Saper::RuntimeMissing)
+    end
+    it "raises no errors when runtime is defined and input is nil" do
+      expect { action.run(nil, runtime) }.to_not raise_error
+    end
+    it "returns Saper::Atom" do
+      action.run(nil, runtime).should be_a(Saper::Items::Atom)
+    end
+  end
+  
+end

data/spec/actions/fetch_spec.rb

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

data/spec/actions/find_first_spec.rb

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

data/spec/actions/find_spec.rb

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

data/spec/actions/get_attribute_spec.rb

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

data/spec/actions/get_contents.rb

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

data/spec/actions/get_text.rb

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

data/spec/actions/prepend_with_spec.rb

@@ -0,0 +1,30 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::PrependWith do
+  
+  let(:action) do
+    Saper::Action.new(:prepend_with, '!')
+  end
+  
+  context ".accepts" do
+    it "returns acceptable input types" do
+      Saper::Actions::AppendWith.accepts.should == [:text]
+    end
+  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
+  
+end

data/spec/actions/remove_after.rb

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

data/spec/actions/remove_before.rb

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

data/spec/actions/replace_spec.rb

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

data/spec/actions/run_recipe_and_save_spec.tmp.rb

@@ -0,0 +1,52 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::RunRecipeAndSave do
+  
+  let(:namespace) do
+    Saper::Namespace.parse do |ns|
+      recipe :child do
+        prepend_with 'test-'
+      end
+      recipe :parent do
+        run_recipe_and_save :variable, :child
+      end
+    end
+  end
+  
+  context "when argument is missing" do
+    it "raises InvalidArgument" do
+      expect { Saper::Action.new(:run_recipe_and_save).run }.to raise_error(Saper::InvalidArgument)
+    end
+  end
+  
+  context "when input is invalid" do
+    let(:runtime) do
+      namespace.run(:parent, nil)
+    end
+    it "raises no errors" do
+      expect { runtime }.to_not raise_error
+    end
+    it "returns valid output" do
+      runtime.results.should == nil
+    end
+    it "sets error flag in runtime" do
+      runtime.error?.should be_true
+    end
+    it "records error in runtime" do
+      runtime.error.should be_a(Saper::InvalidInput)
+    end
+  end
+  
+  context "when input and arguments are valid" do
+    let(:runtime) do
+      Saper::Action.new(:run_recipe_and_save, :variable, :child).run('string', :namespace => namespace)
+    end
+    it "raises no errors" do
+      expect { runtime }.to_not raise_error
+    end
+    it "returns valid output" do
+      runtime.results.should == ['test-string']
+    end
+  end
+  
+end

data/spec/actions/run_recipe_spec.tmp.rb

@@ -0,0 +1,53 @@
+require './spec/spec_helper'
+
+describe Saper::Actions::RunRecipe do
+  
+  let(:child) do
+    Saper::Recipe.new do |recipe|
+      recipe << Saper::Action.new(:prepend_with, 'test-')
+    end
+  end
+  
+  let(:namespace) do
+    Saper::Namespace.new do |ns|
+      ns[:child] = child
+    end
+  end
+  
+  context "when argument is missing" do
+    it "raises InvalidArgument" do
+      expect { Saper::Action.new(:run_recipe).run }.to raise_error(Saper::InvalidArgument)
+    end
+  end
+  
+  context "when input is invalid" do
+    let(:runtime) do
+      Saper::Action.new(:run_recipe, :child).run(nil, :namespace => namespace)
+    end
+    it "raises no errors" do
+      expect { runtime }.to_not raise_error
+    end
+    it "returns valid output" do
+      runtime.results.should == nil
+    end
+    it "sets error flag in runtime" do
+      runtime.error?.should be_true
+    end
+    it "records error in runtime" do
+      runtime.error.should be_a(Saper::InvalidInput)
+    end
+  end
+  
+  context "when input and arguments are valid" do
+    let(:runtime) do
+      Saper::Action.new(:run_recipe, :child).run('string', :namespace => namespace)
+    end
+    it "raises no errors" do
+      expect { runtime }.to_not raise_error
+    end
+    it "returns valid output" do
+      runtime.results.should == 'test-string'
+    end
+  end
+  
+end

data/spec/actions/save_spec.rb

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

data/spec/actions/select_matching_spec.rb

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

data/spec/actions/set_input_spec.rb

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

data/spec/actions/skip_tags_spec.rb

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

data/spec/actions/split_spec.rb

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

data/spec/core/action_spec.rb

@@ -0,0 +1,151 @@
+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
+  end
+  
+  context ".new with unrecognized type" do
+    it "raises ActionNotFound" do
+      expect { Saper::Action.new(:unknown) }.to raise_error(Saper::ActionNotFound)
+    end
+  end
+  
+  context ".accepts" do
+    it "returns an empty array" do
+      Saper::Action.accepts.should == []
+    end
+  end
+  
+  context ".unserialize(Hash)" do
+    it "returns Action instance" do
+      Saper::Action.unserialize({ :type => :test_action }).should be_a(Saper::Action)
+    end
+  end
+  
+  context ".unserialize(Array)" do
+    it "returns an Array" do
+      Saper::Action.unserialize([{ :type => :test_action }, { :type => :test_action }]).should be_a(Array)
+    end
+  end
+  
+  context ".unserialize(nil)" do
+    it "raises InvalidAction" do
+      expect { Saper::Action.unserialize(nil) }.to raise_error(Saper::InvalidAction)
+    end
+  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
+
+