saper 0.5.1 → 0.5.2

data/lib/saper/version.rb

@@ -1,3 +1,3 @@
 module Saper
-  VERSION = "0.5.1"
-end
+  VERSION = "0.5.2"
+end

data/spec/actions/append_with_spec.rb

@@ -1,60 +1,37 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::AppendWith do
-  
-  let(:action) do
+  let :subject do
     Saper::Actions::AppendWith.new('!')
   end
-  
-  context ".new(nil)" do
-    it "raises InvalidArgument" do
-      expect { Saper::Actions::AppendWith.new(nil) }.to raise_error(Saper::InvalidArgument)
-    end
+  it ".new(nil) raises InvalidArgument" do
+    lambda { Saper::Actions::AppendWith.new(nil) }.must_raise(Saper::InvalidArgument)
   end
-  
-  context ".new(Number)" do
-    it "raises InvalidArgument" do
-      expect { Saper::Actions::AppendWith.new(2) }.to raise_error(Saper::InvalidArgument)
-    end
+  it ".new(Numeric) raises InvalidArgument" do
+    lambda { Saper::Actions::AppendWith.new(2) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(Hash) raises InvalidArgumenth" do
+    lambda { Saper::Actions::AppendWith.new({}) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(Array) raises InvalidArgument" do
+    lambda { Saper::Actions::AppendWith.new([]) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(String)returns Action instance" do
+    Saper::Actions::AppendWith.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
-
-  context ".new(String)" do
-    it "raises no errors" do
-      expect { Saper::Actions::AppendWith.new("!") }.to_not raise_error
-    end
-    it "returns Action instance" do
-      Saper::Actions::AppendWith.new("!").should be_a(Saper::Action)
-    end
-  end
-  
-  context "#run(nil)" do
-    it "raises InvalidInput" do
-      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
-  end
-  
-  context "#run(String)" do
-    let(:input) do
-      'string'
-    end
-    it "returns valid output" do
-      action.run(input).should == 'string!'
-    end
-    it "returns Text instance" do
-      action.run(input).should be_a(Saper::Items::Text)
-    end
-  end
-  
-  context "#run(Text)" do
-    let(:input) do
-      Saper::Items::Text.new('string')
-    end
-    it "returns valid output" do
-      action.run(input).should == 'string!'
-    end
-    it "returns Text instance" do
-      action.run(input).should be_a(Saper::Items::Text)
-    end
-  end
-  
 end

data/spec/actions/convert_to_html_spec.rb

@@ -1,39 +1,22 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::ConvertToHTML do
-  
-  let(:action) do
+  let :subject do
     Saper::Actions::ConvertToHTML.new
   end
-  
-  context "#run(nil)" do
-    it "raises InvalidInput" do
-      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
   end
-  
-  context "#run(String)" do
-    let(:input) do
-      '<p>test</p>'
-    end
-    it "raises no errors" do
-      expect { action.run(input) }.to_not raise_error
-    end
-    it "returns HTML instance" do
-      action.run(input).should be_a(Saper::Items::HTML)
-    end
+  it "#run(Numeric) raises InvalidInput" do
+    lambda { subject.run(2) }.must_raise(Saper::InvalidInput)
   end
-
-  context "#run(Text)" do
-    let(:input) do
-      Saper::Items::Text.new('<p>test</p>')
-    end
-    it "raises no errors" do
-      expect { action.run(input) }.to_not raise_error
-    end
-    it "returns HTML instance" do
-      action.run(input).should be_a(Saper::Items::HTML)
-    end
+  it "#run(invalid String) returns HTML instance" do
+    subject.run("not html").must_be_instance_of(Saper::Items::HTML)
+  end
+  it "#run(valid String) returns HTML instance" do
+    subject.run('<p>test</p>').must_be_instance_of(Saper::Items::HTML)
+  end
+  it "#run(valid Text) returns HTML instance" do
+    subject.run(Saper::Items::Text.new('<p>test</p>')).must_be_instance_of(Saper::Items::HTML)
   end
-  
 end

data/spec/actions/convert_to_json_spec.rb

@@ -1,39 +1,22 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::ConvertToJSON do
-  
-  let(:action) do
+  let :subject do
     Saper::Actions::ConvertToJSON.new
   end
-  
-  context "#run(nil)" do
-    it "raises InvalidInput" do
-      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
   end
-  
-  context "#run(String)" do
-    let(:input) do
-      '{"test":"ok"}'
-    end
-    it "raises no errors" do
-      expect { action.run(input) }.to_not raise_error
-    end
-    it "returns JSON instance" do
-      action.run(input).should be_a(Saper::Items::JSON)
-    end
+  it "#run(Numeric) raises InvalidInput" do
+    lambda { subject.run(2) }.must_raise(Saper::InvalidInput)
   end
-
-  context "#run(String)" do
-    let(:input) do
-      Saper::Items::Text.new('{"test":"ok"}')
-    end
-    it "raises no errors" do
-      expect { action.run(input) }.to_not raise_error
-    end
-    it "returns JSON instance" do
-      action.run(input).should be_a(Saper::Items::JSON)
-    end
+  it "#run(invalid String) raises InvalidInput" do
+    subject.run('not json').must_be_nil
+  end
+  it "#run(valid String) returns JSON instance" do
+    subject.run('{"test":"ok"}').must_be_instance_of(Saper::Items::JSON)
+  end
+  it "#run(valid Text) returns JSON instance" do
+    subject.run(Saper::Items::Text.new('{"test":"ok"}')).must_be_instance_of(Saper::Items::JSON)
   end
-  
 end

data/spec/actions/convert_to_markdown_spec.rb

@@ -1,27 +1,25 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::ConvertToMarkdown do
-  
-  let(:action) do
+  let :subject do
     Saper::Actions::ConvertToMarkdown.new
   end
-  
-  context "#run(nil)" do
-    it "raises InvalidInput" do
-      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
+  let :html do
+    Saper::Items::HTML.new('<p>test</p>')
   end
-  
-  context "#run(HTML)" do
-    let(:input) do
-      Saper::Items::HTML.new('<p>test</p>')
-    end
-    it "returns valid output" do
-      action.run(input).should == 'test'
-    end
-    it "returns Markdown instance" do
-      action.run(input).should be_a(Saper::Items::Markdown)
-    end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(Numeric) raises InvalidInput" do
+    lambda { subject.run(2) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(String) raises InvalidInput" do
+    subject.run("string").must_be_instance_of(Saper::Items::Markdown)
+  end
+  it "#run(HTML) returns Markdown instance" do
+    subject.run(html).must_be_instance_of(Saper::Items::Markdown)
+  end
+  it "#run(HTML) returns valid output" do
+    subject.run(html).must_be :==, "test"
   end
-  
 end

data/spec/actions/convert_to_time_spec.rb

@@ -1,52 +1,34 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::ConvertToTime do
-  
-  let(:action_without_tz) do
+  let(:subject_without_tz) do
     Saper::Actions::ConvertToTime.new('%d-%m-%Y %H:%M')
   end
-  
-  let(:action_with_tz) do
+  let(:subject_with_tz) do
     Saper::Actions::ConvertToTime.new('%d-%m-%Y %H:%M', 'Europe/Moscow')
   end
-  
-  context ".new(nil, nil)" do
-    it "raises InvalidArgument" do
-      expect { Saper::Actions::ConvertToTime.new }.to raise_error(Saper::InvalidArgument)
-    end
+  let(:input) do
+    '19-04-2014 18:56'
+  end
+  it ".new(nil, nil) raises InvalidArgument" do
+    lambda { Saper::Actions::ConvertToTime.new }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(format, nil) raises no errors" do
+    lambda { Saper::Actions::ConvertToTime.new("%H") }.must_be_silent
+  end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject_without_tz.run(nil) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(valid String) returns valid output with defined TZ" do
+    subject_with_tz.run(input).to_s.must_be :==, '2014-04-19T18:56:00+04:00'
+  end
+  it "#run(valid String) returns valid output with undefined TZ" do
+    subject_without_tz.run(input).to_s.must_be :==, '2014-04-19T18:56:00+00:00'
+  end
+  it "#run(valid String) returns Time instance" do
+    subject_with_tz.run(input).must_be_instance_of(Saper::Items::Time)
+  end
+  it "#run(invalid String) raises InvalidItem" do
+    lambda { subject_with_tz.run("ABCDEF") }.must_raise(Saper::InvalidItem)
   end
-
-  context ".new(format, nil)" do
-    it "raises no errors" do
-      expect { Saper::Actions::ConvertToTime.new("%H") }.to_not raise_error
-    end
-  end
-  
-  context "#run(nil)" do
-    it "raises InvalidInput" do
-      expect { action_without_tz.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
-  end
-  
-  context "#run(valid date)" do
-    let(:input) do
-      '19-04-2014 18:56'
-    end
-    it "returns valid output if TZ is set" do
-      action_with_tz.run(input).should == '2014-04-19T18:56:00+04:00'
-    end
-    it "returns valid output if TZ is missing" do
-      action_without_tz.run(input).should == '2014-04-19T18:56:00+00:00'
-    end
-    it "returns Time instance" do
-      action_with_tz.run(input).should be_a(Saper::Items::Time)
-    end
-  end
-    
-  context "#run(invalid date)" do
-    it "raises InvalidItem" do
-      expect { action_with_tz.run("ABCDEF") }.to raise_error(Saper::InvalidItem)
-    end
-  end
-  
 end

data/spec/actions/convert_to_xml_spec.rb

@@ -1,18 +1,22 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::ConvertToXML do
-  
-  let(:action) do
+  let :subject do
     Saper::Actions::ConvertToXML.new
   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
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(Numeric) raises InvalidInput" do
+    lambda { subject.run(2) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(invalid String) returns XML instance" do
+    subject.run("not xml").must_be_instance_of(Saper::Items::XML)
+  end
+  it "#run(valid String) returns XML instance" do
+    subject.run('<root>test</root>').must_be_instance_of(Saper::Items::XML)
+  end
+  it "#run(valid Text) returns XML instance" do
+    subject.run(Saper::Items::Text.new('<root>test</root>')).must_be_instance_of(Saper::Items::XML)
   end
-  
 end

data/spec/actions/create_atom_spec.rb

@@ -1,27 +1,19 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::CreateAtom do
-  
-  let(:action) do
+  let :subject do
     Saper::Actions::CreateAtom.new
   end
-  
-  context "#run(nil)" do
-    it "raises RuntimeMissing" do
-      expect { action.run(nil) }.to raise_error(Saper::RuntimeMissing)
-    end
+  let :runtime do
+    Saper::Runtime.new :test => 'ok'
   end
-  
-  context "#run(nil, Runtime)" do
-    let(:runtime) do
-      Saper::Runtime.new
-    end
-    it "raises no errors" 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
+  it "#run(nil) returns Saper::Atom" do
+    subject.run(nil).must_be_instance_of(Saper::Items::Atom)
+  end
+  it "#run(nil, Runtime) returns Saper::Atom" do
+    subject.run(nil, runtime).must_be_instance_of(Saper::Items::Atom)
+  end
+  it "#run(nil, Runtime) returns valid output" do
+    subject.run(nil, runtime).to_native.must_equal(:test => 'ok')
   end
-  
 end

data/spec/actions/fetch_spec.rb

@@ -1,15 +1,10 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::Fetch do
-  
-  let(:action) do
+  let :subject do
     Saper::Actions::Fetch.new
   end
-  
-  context "#run(nil)" do
-    it "raises InvalidInput" do
-      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
   end
-  
 end

data/spec/actions/find_first_spec.rb

@@ -1,52 +1,50 @@
 require './spec/spec_helper'
 
 describe Saper::Actions::FindFirst do
-  
-  let(:action) do
+  subject do
     Saper::Actions::FindFirst.new("//p")
   end
-  
-  context ".new(nil)" do
-    it "raises InvalidArgument" do
-      expect { Saper::Actions::FindFirst.new(nil) }.to raise_error(Saper::InvalidArgument)
-    end
+  let :string do
+    "<html><body><div><p>test</p></div></body></html>"
   end
-  
-  context ".new(CSS)" do
-    it "raises no errors" do
-      expect { Saper::Actions::FindFirst.new("a") }.to_not raise_error
-    end
+  let :html do
+    Saper::Items::HTML.new(string)
   end
-  
-  context "#run(nil)" do
-    it "raises InvalidInput" do
-      expect { action.run(nil) }.to raise_error(Saper::InvalidInput)
-    end
+  let :json do
+    Saper::Items::JSON.new('{"p":{"a":0}}')
   end
-  
-  context "#run(HTML)" do
-    let(:input) do
-      Saper::Items::HTML.new('<div><p>test</p></div>')
-    end
-    it "returns HTML instance" do
-      action.run(input).should be_a(Saper::Items::HTML)
-    end
-    it "returns valid output" do
-      action.run(input).name.should == 'p'
-    end
+  it ".new(nil) raises InvalidArgument" do
+    lambda { Saper::Actions::FindFirst.new(nil) }.must_raise(Saper::InvalidArgument)
   end
-  
-  context "#run(JSON)" do
-    let(:input) do
-      Saper::Items::JSON.new('{"p":{"a":0}}')
-    end
-    it "returns JSON instance" do
-      action.run(input).should be_a(Saper::Items::JSON)
-    end
-    it "returns valid output" do
-      action.run(input).to_s.should == '{"a":0}'
-    end
-    
+  it ".new(Numeric) raises InvalidArgument" do
+    lambda { Saper::Actions::FindFirst.new(1) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(Hash) raises InvalidArgument" do
+    lambda { Saper::Actions::FindFirst.new({}) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(Array) raises InvalidArgument" do
+    lambda { Saper::Actions::FindFirst.new([]) }.must_raise(Saper::InvalidArgument)
+  end
+  it ".new(CSS as String) raises no errors" do
+    lambda { Saper::Actions::FindFirst.new("a") }.must_be_silent
+  end
+  it "#run(nil) raises InvalidInput" do
+    lambda { subject.run(nil) }.must_raise(Saper::InvalidInput)
+  end
+  it "#run(String) returns HTML instance" do
+    subject.run(string).must_be_instance_of(Saper::Items::HTML)
+  end
+  it "#run(HTML) returns HTML instance" do
+    subject.run(html).must_be_instance_of(Saper::Items::HTML)
+  end
+  it "#run(HTML) returns valid output" do
+    subject.run(html).to_s.must_be :==, '<p>test</p>'
+  end
+  it "#run(JSON) returns JSON instance" do
+    subject.run(json).must_be_instance_of(Saper::Items::JSON)
+  end
+  it "#run(JSON) returns valid output" do
+    subject.run(json).must_be :==, {"a" => 0}
   end
   
 end