rspec-i18n 0.2.1 → 1.0.0

data/spec/spec-i18n/matchers/be_close_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Spec
+  module Matchers
+    describe "[actual.should] be_close(expected, delta)" do
+      
+      before(:each) do
+        @expected_matcher = {'matchers' => { 'be_close' => 'estar_perto'} }
+        portuguese_language(@expected_matcher)
+        Spec::Matchers.register_all_matchers
+      end
+      
+      it "should register the be_close matcher" do
+        values = @expected_matcher['matchers']['be_close'].split('|')
+        values.each do |value_method|
+          Object.instance_methods.should be_include(value_method)
+        end
+      end
+      
+      it "matches when actual == expected" do
+        estar_perto(5.0, 0.5).matches?(5.0).should be_true
+      end
+      
+      it "matches when actual < (expected + delta)" do
+        estar_perto(5.0, 0.5).matches?(5.49).should be_true
+      end
+      
+      it "does not match when actual == (expected - delta)" do
+        estar_perto(5.0, 0.5).matches?(4.5).should be_false
+      end
+      it "does not match when actual < (expected - delta)" do
+        estar_perto(5.0, 0.5).matches?(4.49).should be_false
+      end
+      it "does not match when actual == (expected + delta)" do
+        estar_perto(5.0, 0.5).matches?(5.5).should be_false
+      end
+      
+    end
+  end
+end

data/spec/spec-i18n/matchers/be_instance_of_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Spec
+  module Matchers
+    describe 'the be_instance_of method' do
+      
+      before(:each) do
+        @expected_matcher = { 'matchers' => { 'be_an_instance_of' => 'ser_instancia_de'} }
+        portuguese_language(@expected_matcher)
+        Spec::Matchers.register_all_matchers
+      end
+      
+      it "register the be_an_instance_of method" do
+        values = @expected_matcher['matchers']['be_an_instance_of'].split('|')
+        values.each do |value_method|
+          Object.instance_methods.should be_include(value_method)
+        end
+      end
+      
+      it "passes if actual is instance of expected class" do
+        5.should send(:ser_instancia_de, Fixnum)
+      end
+      
+      it "fails if actual is instance of subclass of expected class" do
+        lambda { 
+          5.should send(:ser_instancia_de, Numeric)          
+        }.should raise_error
+      end
+      
+    end
+  end
+end

data/spec/spec-i18n/matchers/be_kind_of_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Spec
+  module Matchers
+    describe 'the be_kind_of method' do
+      
+      before(:each) do
+        @expected_matcher = { 'matchers' => { 'be_a_kind_of' => 'ser_do_tipo'} }
+        portuguese_language(@expected_matcher)
+        Spec::Matchers.register_all_matchers
+      end
+      
+      it "register the be_an_instance_of method" do
+        values = @expected_matcher['matchers']['be_a_kind_of'].split('|')
+        values.each do |value_method|
+          Object.instance_methods.should be_include(value_method)
+        end
+      end
+      
+      it "passes if actual is instance of expected class" do
+        5.should send(:ser_do_tipo, Fixnum)
+      end
+
+      it "passes if actual is instance of subclass of expected class" do
+        5.should send(:ser_do_tipo, Numeric)
+      end
+
+      it "fails with failure message for should unless actual is kind of expected class" do
+        lambda { 
+          "foo".should send(:ser_do_tipo, Array) 
+        }.should raise_error
+      end
+      
+    end
+    
+  end
+end

data/spec/spec-i18n/matchers/be_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "should be_predicate" do
+  
+  before(:each) do
+    portuguese_language({"matchers" => {"be" => "ser"}})
+    Spec::Matchers.register_all_matchers
+  end
+  
+  it "should pass with be language translated" do
+    atual = stub("atual", :feliz? => true)
+    atual.should ser_feliz
+  end
+  
+  it "should fail when actual returns false for :predicate?" do
+    
+    
+    pending('verify rspec 1.3')
+    
+    atual = stub("atual", :feliz? => false)
+    lambda {
+      atual.should be_feliz
+    }.should fail_with("expected feliz? to return true, got false")
+  end
+  
+  it "should fail when actual returns false for :predicate?" do
+    
+    pending('verify rspec 1.3')
+    
+    atual = stub("atual", :feliz? => nil)
+    lambda {
+      atual.should be_feliz
+    }.should fail_with("expected feliz? to return true, got nil")
+  end
+  
+  it 'should be true for the new :predicate' do
+    atual = true
+    pending("SHOULD translate true, false, nil, empty for the default MATCHERS")
+    atual.should ser_true
+  end
+  
+  it 'should convert be word to english with two parameters' do
+    be_to_english(:ser_feliz, 'ser|estar').should == :be_feliz
+  end
+  
+  it "should convert be word to english" do
+    be_to_english(:ser_feliz, :ser).should == :be_feliz
+  end
+  
+  it "should keep the same word in english(don't break the rspec defaults)" do
+    be_to_english(:be_include, :be).should == :be_include
+  end
+  
+  it "should keep the same word for the non existing word" do
+    be_to_english(:be_include, :ser).should == :be_include
+  end
+  
+  it "should keep the same word for the nil be word" do
+    be_to_english(:be_include, nil).should == :be_include
+  end
+end

data/spec/spec-i18n/matchers/eql_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Spec
+  module Matchers
+    describe "eql" do
+      
+      before(:each) do
+        @expected_matcher = {'matchers' => {'eql' => 'igl'}}
+        portuguese_language(@expected_matcher)
+        Spec::Matchers.register_all_matchers
+      end
+      
+      it "should have eql matchers translated" do
+        eql_word = @expected_matcher['matchers']['eql']
+        1.methods.should be_include(eql_word)
+      end
+      
+      it "should have eql? matchers translated" do
+        eql_word = @expected_matcher['matchers']['eql'] + '?'
+        1.methods.should be_include(eql_word)
+      end
+      
+      it "should match when actual.eql?(expected)" do
+        1.should igl(1)
+      end
+      
+      it "should not match when !actual.eql?(expected)" do
+        1.should_not igl(2)
+      end
+      
+    end
+  end
+end

data/spec/spec-i18n/matchers/equal_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+module Spec
+  module Matchers
+    describe 'equal' do
+      before(:each) do
+        @expected_matcher = {'matchers' => {'equal' => 'igual|igual_a'}}
+        portuguese_language(@expected_matcher)
+        Spec::Matchers.register_all_matchers
+      end
+      
+      it 'should register the methods for the value equal matcher' do
+        values = @expected_matcher['matchers']['equal'].split('|') 
+        values.each { |method_name| Object.instance_methods.should be_include(method_name) }
+      end
+      
+      it "should match when actual.equal?(expected)" do
+        1.should igual(1)
+      end
+
+      it "should not match when !actual.equal?(expected)" do
+        1.should_not igual_a("1")
+      end
+    end
+  end
+end

data/spec/spec-i18n/matchers/exist_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+# The same class in rspec specs file
+class Substance
+  def initialize exists, description
+    @exists = exists
+    @description = description
+  end
+  def exist?(arg=nil)
+    @exists
+  end
+end
+
+module Spec
+  module Matchers
+    
+    describe "exist matcher" do
+      
+      before(:each) do
+        @expected_matcher = {'matchers' => {'exist' => 'existir'}}
+        portuguese_language(@expected_matcher)
+        Spec::Matchers.register_all_matchers
+        @real = Substance.new true, 'something real'
+        @imaginary = Substance.new false, 'something imaginary'
+      end
+      
+      it 'should register the exist method translated' do
+        values = @expected_matcher['matchers']['exist'].split('|')
+        values.each do |value_method|
+          Object.instance_methods.should be_include(value_method)
+        end
+      end
+      
+      it "passes if target exists" do
+        @real.should existir
+      end
+      
+      it "fails if target does not exist" do
+        lambda { @imaginary.should exist }.should raise_error
+      end
+      
+    end
+    
+  end
+end

data/spec/spec-i18n/matchers/have_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe 'have, have_exactly, have_at_least and have_at_most matcher' do
+  
+  before(:each) do
+    matchers = {'have' => 'ter', 'have_at_least' => 'ter_no_minimo', 
+                'have_exactly' => 'ter_exatamente', 
+                'have_at_most' => 'ter_no_maximo'}
+    @expected_matcher = {'matchers' => matchers}
+    portuguese_language(@expected_matcher)
+    Spec::Matchers.register_all_matchers
+  end
+  
+  describe 'should have(n).items' do
+  
+    it 'should pass if target has a collection of items with n members' do
+      [1, 2, 3].should ter(3).items
+    end
+    
+    it "should pass if target has a collection of items with < n members" do
+      [1, 2, 3].should_not ter(4).items
+    end
+  
+  end
+  
+  describe 'should have_exactly(n).items' do
+    
+    it "should pass if target has a collection of items with n members" do
+      [1,2,3].should ter_exatamente(3).items
+    end
+    
+    it 'should fail if target has a collection of items with < n members' do
+      [1,2,3].should_not ter_exatamente(4).items
+    end
+    
+  end
+  
+  describe "should have_at_least(n).items" do
+
+    it "should pass if target has a collection of items with n members" do
+      [1, 2, 3].should ter_no_minimo(3).items
+    end
+    
+    it "should fail if target has a collection of items with < n members" do
+      [1, 2, 3].should_not ter_no_minimo(4).items
+    end
+    
+  end
+  
+  describe "should have_at_most(n).items" do
+
+    it "should pass if target has a collection of items with n members" do
+      [1, 2, 3].should ter_no_maximo(3).items
+    end
+
+    it "should fail if target has a collection of items with > n members" do
+      [1, 2, 3].should_not ter_no_maximo(2).items
+    end
+  end
+  
+end

data/spec/spec-i18n/matchers/include_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "should include(expected)" do
+  before(:each) do
+    @expected_matcher = {'matchers' => { 'include' => 'incluir'} }
+    portuguese_language(@expected_matcher)
+    Spec::Matchers.register_all_matchers
+  end
+  
+  it "should translated the include matcher" do
+    values = @expected_matcher['matchers']['include'].split('|')
+    
+    values.each do |value_method|
+      Object.instance_methods.should be_include(value_method)
+    end
+    
+  end
+  
+  it "should pass if target includes expected" do
+    [1,2,3].should incluir(3)
+    "abc".should incluir("a")
+  end
+  
+  it 'should pass if target is a Hash and has the expected as a key' do
+    {:key => 'value'}.should incluir(:key)
+  end
+  
+  it "should fail if target does not include expected" do
+    lambda {
+      [1,2,3].should incluir(4)
+    }.should raise_error
+  end
+  
+end

data/spec/spec-i18n/matchers/match_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe "should match(expected)" do
+  before(:each) do
+    @expected_matcher = {'matchers' => { 'match' => 'corresponder'} }
+    portuguese_language(@expected_matcher)
+    Spec::Matchers.register_all_matchers
+  end
+  
+  it "should translated the include matcher" do
+    values = @expected_matcher['matchers']['match'].split('|')
+    values.each do |value_method|
+      Object.instance_methods.should be_include(value_method)
+    end
+  end
+  
+  it "should pass when target (String) matches expected (Regexp)" do
+    "string".should corresponder(/tri/)
+  end
+
+  it "should pass when target (String) matches expected (String)" do
+    "string".should corresponder("tri")
+  end
+
+  it "should fail when target (String) does not match expected (Regexp)" do
+    lambda {
+      "string".should corresponder(/rings/)
+    }.should raise_error
+  end
+
+  it "should fail when target (String) does not match expected (String)" do
+    lambda {
+      "string".should corresponder("rings")
+    }.should raise_error
+  end
+end

data/spec/spec-i18n/matchers/raise_error_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "should raise_error" do
+  
+  before(:each) do
+    @expected_matcher = {'matchers' => {'raise_error' => 'mostrar_erro'}}
+    portuguese_language(@expected_matcher)
+    Spec::Matchers.register_all_matchers
+  end
+  
+  it 'should register the methods for the value equal matcher' do
+    values = @expected_matcher['matchers']['raise_error'].split('|') 
+    values.each { |method_name| Object.instance_methods.should be_include(method_name) }
+  end
+  
+  it "should pass if anything is raised" do
+    lambda {raise}.should mostrar_erro
+  end
+  
+  it "should fail if nothing is raised" do
+    lambda {
+      lambda {}.should mostrar_erro
+    }.should mostrar_erro
+  end
+end

data/spec/spec-i18n/matchers/register_all_matchers_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module SpecI18n
+  module Matchers
+    describe 'register all matcher' do
+      
+      before(:each) do
+        Spec::Runner.configuration.spec_language('pt')
+      end
+      
+      it 'should not raise error for register all the words for i18n' do
+        lambda { Spec::Matchers.register_all_matchers }.should_not raise_error
+      end
+      
+    end
+  end
+end

data/spec/spec-i18n/matchers/satisfy_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "should satisfy { block }" do
+  
+  before(:each) do
+    @expected_matcher = { 'matchers' => { 'satisfy' => 'satisfazer'} }
+    portuguese_language(@expected_matcher)
+    Spec::Matchers.register_all_matchers
+  end
+  
+  it 'should trasnlate the satisfy matcher' do
+    values = @expected_matcher['matchers']['satisfy'].split('|')
+    values.each do |value_method|
+      Object.instance_methods.should be_include(value_method)
+    end
+  end
+  
+  it "should pass if block returns true" do
+    true.should satisfazer { |val| val }
+    true.should satisfazer do |val|
+      val
+    end
+  end
+
+  it "should fail if block returns false" do
+    false.should_not satisfazer { |val| val }
+  end
+end

data/spec/spec-i18n/parser/natural_language_spec.rb

@@ -25,71 +25,23 @@ module SpecI18n
 
       end
       
-      context "imcomplete languages" do
+      context "incomplete languages" do
         
-        it "should return true for the complete language" do
-          @pt.incomplete?.should be_true
-        end
-        
-        it "should return false for the imcomplete language" do
-          @pt.stub!(:keywords).and_return({ :name => []})
+        it "should return false for the complete language" do
           @pt.incomplete?.should be_false
         end
         
-      end
-      
-      context "list languages" do
-        
-        before(:each) do
-          @portuguese = ["pt", "Portuguese", "português"]
-          @spanish = ["es", "Spanish", "español"]
-        end
-        
-        it "should return the three keywords language for portuguese" do
-          SpecI18n::SPEC_LANGUAGES.should_receive(:keys).and_return("pt")
-          NaturalLanguage.list_languages.should == [@portuguese]
-        end
-        
-        it "should return the three keywords for spanish" do
-          SpecI18n::SPEC_LANGUAGES.should_receive(:keys).and_return("es")
-          NaturalLanguage.list_languages.should == [@spanish]
+        it "should return true for the incomplete language" do
+          @pt.stub!(:keywords).and_return({ :name => []})
+          @pt.incomplete?.should be_true
         end
         
-        it "should return the three keywords for spanish and portuguese" do
-          SpecI18n::SPEC_LANGUAGES.should_receive(:keys).and_return(["pt", "es"])
-          NaturalLanguage.list_languages.should == [@portuguese, @spanish].sort
-        end
       end
       
-      context "list all keywords" do
-        
-        before(:each) do
-          @portuguese = NaturalLanguage.get("pt")
-        end
-        
-        # TODO: It's 3 a.m in the morning ... Ugly Specs ... #FIXME
-        
-        it "should return the name keyword for the portuguese language" do
-          name = ["name", "Portuguese"]
-          NaturalLanguage.list_keywords("pt").first.should == name
-        end
-        
-        it "should return the example keyword for the portuguese language" do
-          keywords = NaturalLanguage.list_keywords('pt')
-          example = keywords.map { |array| array if array.include?("it") }.compact.flatten
-          example.should == ["it", "exemplo / especificar"]
-        end
-        
-        it "should return all the keywords for the spanish language" do
-          native = ["native", "español"]
-          NaturalLanguage.list_keywords('es')[1].should == native
-        end
-        
-      end
-
       %w(describe before after it should name native).each do |keyword|
         it "should have the #{keyword} keyword" do
-          @pt.keywords.keys.should be_include(keyword)
+          portuguese_keys = @pt.keywords.keys          
+          portuguese_keys.should include(keyword)
         end
       end
 
@@ -163,20 +115,52 @@ module SpecI18n
         end
       end
 
-      context "of all matchers" do
-        it "should parse all matchers"
+      context 'of example subject keywords' do
+        
+        before(:each) do
+          @keywords = { "subject" => "assunto|tema" }
+          @spanish_keywords = { 'subject' => 'asunto|tema'}
+        end
+
+        it 'should return the subject keywords' do
+          @pt.stub!(:keywords).and_return(@keywords)
+          @pt.subject_keywords.should == {'subject' => ["assunto", "tema"]}
+        end
+
+        it 'should return the subject keywords for spanish language' do
+          @spanish_keywords.stub!(:keywords).and_return(@spanish_keywords)
+          @es.subject_keywords.should == { 'subject' => ['asunto', 'tema']}
+        end
       end
 
+      context 'of example its keywords' do
+        
+        before(:each) do
+          @keywords = { "its" => "exemplos" }
+          @spanish_keywords = { 'its' => 'ejemplos'}
+        end
+
+        it 'should return the its keywords' do
+          @pt.stub!(:keywords).and_return(@keywords)
+          @pt.its_keywords.should == {'its' => ["exemplos"]}
+        end
+
+        it 'should return the its keywords for spanish language' do
+          @es.stub!(:keywords).and_return(@spanish_keywords)
+          @es.its_keywords.should == { 'its' => ['ejemplos']}
+        end
+      end
       context "splitting the keys" do
         it "should raise no found key" do
           lambda {
             @pt.spec_keywords("no_found")
+            @pt.spec_keywords("Oh_MY_this_words_is_not_found!")
           }.should raise_error(RuntimeError)
         end
 
         it "should split correctly the keys" do
          lang = { "describe" => "descreva|contexto" }
-         NaturalLanguage.instance_variable_set(:@keywords, lang["describe"])
+         @pt.stub!(:keywords).and_return(lang)
          @pt.spec_keywords("describe").should == { "describe" => ["descreva", "contexto"] }
         end
       end