transifex-interface-ruby 0.0.1 → 0.0.2

data/spec/lib/transifex/resources_spec.rb

@@ -1,50 +1,58 @@
-require_relative "../../spec_helper"
+require "spec_helper"
 
-describe Transifex::Resources do 
+describe Transifex::Resources do
+  let(:project) { Transifex::Project.new("ruby-client") }
 
-  before(:all) do 
-    @correct_project = Transifex::Project.new("projet-de-test-1")
-    @wrong_project = Transifex::Project.new("lll")
-  end
-
-  it "should raise an error if instanciated without a project_slug" do
-    expect{ Transifex::Resources.new() }.to raise_error(Transifex::MissingParametersError)
+  describe "Instantiation" do
+    it "should raise an error if the project_slug is not provided" do
+      expect { Transifex::Resources.new }.to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: project_slug")
+    end
   end
 
   describe "Fetch" do
-    it "should not raise any error and return a hash" do
-      resources_instance = @correct_project.resources
-      fetched_resources = nil
-      expect{ fetched_resources = resources_instance.fetch }.to_not raise_error
-      expect(fetched_resources).to be_a_kind_of(Array)
-      expect(fetched_resources.first).to be_a_kind_of(Hash)
-      expect(fetched_resources.first.keys).to contain_exactly("source_language_code", "name", "i18n_type", "priority", "slug", "categories")
+    it "should retrieve the resources as an array of hashes, one for each resource" do
+      VCR.use_cassette "resources/fetch_as_array" do
+        expect(project.resources.fetch).to eq all_project_resources_array
+      end
     end
 
-    it "should raise an error if project doesn't exist" do
-      resources_instance = @wrong_project.resources
-      fetched_resources = nil
-      expect{ fetched_resources = resources_instance.fetch }.to raise_error(Transifex::TransifexError)
+    it "should raise an error if the project doesn't exist" do
+      non_existing_project = Transifex::Project.new("not_existing_project")
+
+      VCR.use_cassette "resources/non_existing_project" do
+        expect { non_existing_project.resources.fetch }.to raise_error(Transifex::TransifexError)
+          .with_message("Not Found")
+      end
     end
   end
 
   describe "Create" do
-    it "should raise an error if required parameters are missing" do
-      expect{ @correct_project.resources.create }.to raise_error(Transifex::MissingParametersError)
-    end  
-
-    it "should create a new resource for the project without using a file" do
-      expect{ @correct_project.resources.create({:slug => "p", :name => "without_file", :i18n_type => "TXT", :content => "test"}) }.to_not raise_error
+    it "should raise an error if the required parameters are missing" do
+      expect { project.resources.create }.to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: slug, name, i18n_type, content")
     end
 
-    it "should create a new resource for the project using a file" do
-      options = {:trad_from_file => true}      
-      expect{ @correct_project.resources.create({:slug => "q", :name => "with_file", :i18n_type => "YAML", :content => get_yaml_source_trad_file_path('en')}, options) }.to_not raise_error
+    it "should create a new resource in the project without using a file" do
+      resource_attributes = {slug: "string_resource", name: "without file", i18n_type: "TXT", content: "test"}
+
+      VCR.use_cassette "resources/create_from_string" do
+        expect(project.resources.create(resource_attributes)).to eq successful_resource_creation
+      end
     end
-  end
 
-  after(:all) do
-    @correct_project.resource("q").delete
-    @correct_project.resource("p").delete
+    it "should create a new resource in the project using a file" do
+      resource_attributes = {
+        slug: "file_resource",
+        name: "with file",
+        i18n_type: "YML",
+        content: get_yaml_source_trad_file_path("eo")
+      }
+      options = {trad_from_file: true}
+
+      VCR.use_cassette "resources/create_from_file" do
+        expect(project.resources.create(resource_attributes, options)).to eq successful_resource_creation
+      end
+    end
   end
-end
+end

data/spec/lib/transifex/reviewers_spec.rb

@@ -1,32 +1,38 @@
-require_relative '../../spec_helper'
+require "spec_helper"
 
 describe Transifex::ProjectComponents::LanguageComponents::Reviewers do
-  before(:all) do
-    @project = Transifex::Project.new("projet-de-test-1")
-  end
+  let(:project) { Transifex::Project.new("ruby-client") }
 
-  describe "Instanciation" do
-    it "should raise an error when no parameters given" do
-      expect{ Transifex::ProjectComponents::LanguageComponents::Reviewers.new }.to raise_error(Transifex::MissingParametersError)
+  describe "Instantiation" do
+    it "should raise an error if the project_slug is not provided" do
+      expect{ Transifex::ProjectComponents::LanguageComponents::Reviewers.new }
+        .to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: project_slug")
     end
   end
 
   describe "Fetch" do
-    it "should not raise an error and retrieve the language's informations" do
-      language_coordinators_infos = nil
-      expect{ language_coordinators_infos = @project.language('en').reviewers.fetch }.to_not raise_error
-      expect(language_coordinators_infos).to be_a_kind_of(Hash)
-      expect(language_coordinators_infos.keys).to contain_exactly("reviewers")
+    it "retrieves the language reviewers" do
+      VCR.use_cassette "project/language/fetch_reviewers" do
+        expect(project.language("en").reviewers.fetch).to eq({"reviewers" => ["wirido"]})
+      end
     end
   end
 
   describe "Update" do
-    it "should not raise an error and update the coordinators list" do
-      expect{ @project.language('en').reviewers.update(['fredericgrais'])}.to_not raise_error
+    it "updates the reviewers list" do
+      VCR.use_cassette "project/language/update_reviewers" do
+        expect(project.language("en").reviewers.update(["mupo"])).to eq("OK")
+        expect(project.language("en").reviewers.fetch).to eq({"reviewers" => ["mupo"]})
+      end
     end
 
-    it "should raise an error if the coordinator doesn't exist" do
-      expect{ @project.language('en').reviewers.update(['grgrgef'])}.to raise_error(Transifex::TransifexError)
+    it "should raise an error if the reviewer doesn't exist" do
+      VCR.use_cassette "project/language/update_non_existing_reviewer" do
+        expect { project.language("en").reviewers.update(['not_existing_reviewer'])}
+          .to raise_error(Transifex::TransifexError)
+          .with_message("Users not_existing_reviewer do not exist.")
+      end
     end
   end
-end
+end

data/spec/lib/transifex/stats_spec.rb

@@ -1,34 +1,30 @@
-require_relative "../../spec_helper"
+require "spec_helper"
 
-describe Transifex::ResourceComponents::Stats do 
-  before(:all) do
-    @project = Transifex::Project.new("projet-de-test-1")
-    @resource = @project.resource("test")
-  end
+describe Transifex::ResourceComponents::Stats do
+  let(:project) { Transifex::Project.new("ruby-client") }
 
-  describe "Instanciation" do
+  describe "Instantiation" do
     it "should raise an error when no parameters given" do
-      expect{ Transifex::ResourceComponents::Stats.new }.to raise_error(ArgumentError)
+      expect { Transifex::ResourceComponents::Stats.new }.to raise_error(ArgumentError)
     end
   end
 
   describe "Fetch" do
-    it "should retrieve the stats for all languages as a hash" do
-      resource_stats = nil
-      resource_details = @project.resource("test").fetch_with_details
-      resource_available_languages = resource_details["available_languages"].map{|language| language["code"]}
-      expect{ resource_stats = @resource.statistics.fetch }.to_not raise_error
-      expect(resource_stats).to be_a_kind_of(Hash)
-      expect(resource_stats.keys).to match_array(resource_available_languages)
-    end 
-    it "should retrieve the stats for a specific language as a hash" do
-      resource_stats = nil
-      expect{ resource_stats = @resource.statistics.fetch("en") }.to_not raise_error
-      expect(resource_stats).to be_a_kind_of(Hash)
-      expect(resource_stats.keys).to contain_exactly("reviewed_percentage", "completed", "untranslated_words", "last_commiter", "reviewed", "translated_entities", "translated_words", "last_update", "untranslated_entities")
+    it "should retrieve the stats of a resource for all languages as a hash" do
+      VCR.use_cassette "resource/fetch_all_languages_stats" do
+        expect(project.resource("test").statistics.fetch).to eq all_languages_stats
+      end
     end
-  end
-
 
+    it "should retrieve the stats of a resource for a specific language as a hash" do
+      Transifex.configure do |c|
+              c.client_login = "m.giambitto@freegoweb.it"
+              c.client_secret = "molli_01"
+            end
 
-end
+      VCR.use_cassette "resource/fetch_language_stats" do
+        expect(project.resource("test").statistics.fetch("en")).to eq all_languages_stats["en"]
+      end
+    end
+  end
+end

data/spec/lib/transifex/translation_spec.rb

@@ -1,53 +1,75 @@
-require_relative "../../spec_helper"
+require "spec_helper"
 
-describe Transifex::ResourceComponents::Translation do 
-  before(:all) do
-    @project = Transifex::Project.new("projet-de-test-1")
-    @resource = @project.resource("test")
-  end
+describe Transifex::ResourceComponents::Translation do
+  let(:project) { Transifex::Project.new("ruby-client") }
+  let(:resource) { project.resource("test") }
 
-  describe "Instanciation" do
-    it "should raise an error when no parameters given" do
-      expect{ Transifex::ResourceComponents::Translation.new }.to raise_error(Transifex::MissingParametersError)
+  describe "Instantiation" do
+    it "should raise an error if the project_slug is missing" do
+      expect { Transifex::ResourceComponents::Translation.new }.to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: project_slug")
     end
   end
 
   describe "Fetch" do
-    it "should raise an error if no language code is provided" do
-      expect{ resource_stats = @resource.translation.fetch }.to raise_error(Transifex::MissingParametersError)
-    end
-    it "should retrieve the translation content as a hash" do
-      translation_content = nil
-      expect{ translation_content = @resource.translation('en').fetch }.to_not raise_error
-      expect(translation_content).to be_a_kind_of(Hash)
-      expect(translation_content.keys).to contain_exactly("content", "mimetype")
+    describe "#fetch" do
+      it "should raise an error if no language code is provided" do
+        VCR.use_cassette "resource/fetch_without_language_code_translations" do
+          expect { resource.translation.fetch }.to raise_error(Transifex::MissingParametersError)
+            .with_message("The following attributes are missing: translation_slug")
+        end
+      end
+
+      it "should retrieve a resource translation content as a hash" do
+        VCR.use_cassette "resource/fetch_translations" do
+          expect(resource.translation("en").fetch).to eq translation_content
+        end
+      end
     end
-    it "should retrieve the translation content as a file with default mode" do
-      translation_content = nil
-      path_to_file = File.dirname(__FILE__) + "/../yaml/resource_translation_default_content_test.yml"
-      options = {:path_to_file => path_to_file}
-      expect{ translation_content = @resource.translation('fr').fetch_with_file(options) }.to_not raise_error
-      file_exist = File.file?(path_to_file)
-      expect(file_exist).to eq(true)
-    end      
-    it "should retrieve the translation content as a file with a mode" do
-      translation_content = nil
-      path_to_file = File.dirname(__FILE__) + "/../yaml/resource_translation_reviewed_content_test.yml"
-      options = {:path_to_file => path_to_file, :mode => "reviewed"}      
-      expect{ translation_content = @resource.translation('en').fetch_with_file(options) }.to_not raise_error
-      file_exist = File.file?(path_to_file)
-      expect(file_exist).to eq(true)
+
+    describe "#fetch_with_file" do
+      it "should retrieve the translation content as a file with default mode" do
+        path_to_file = "translations.yml"
+        options = {path_to_file: path_to_file}
+
+        VCR.use_cassette "resource/fetch_with_file_translations" do
+          resource.translation("en").fetch_with_file(options)
+
+          expect(File.exist?(path_to_file)).to be true
+          expect(File.read(path_to_file)).to eq file_translation_content
+        end
+      end
+
+      it "should retrieve the translation content as a file with a specific mode" do
+        path_to_file = "translations.yml"
+        options = {path_to_file: path_to_file, mode: "translator"}
+
+        VCR.use_cassette "resource/fetch_with_file_and_mode_translations" do
+          resource.translation("en").fetch_with_file(options)
+
+          expect(File.exist?(path_to_file)).to be true
+          expect(File.read(path_to_file)).to eq file_translation_content_with_mode
+        end
+      end
     end
   end
 
   describe "Update" do
     it "sould raise an error if try to update source language" do
-      options = {:i18n_type => "YAML", :content => get_yaml_source_trad_file_path('en')}
-      expect{ translation_content = @resource.translation('en').update(options) }.to raise_error(Transifex::TransifexError)
+      options = {i18n_type: "YAML", content: get_yaml_source_trad_file_path("eo")}
+
+      VCR.use_cassette "resource/update_source_language" do
+        expect { resource.translation("eo").update(options) }.to raise_error(Transifex::TransifexError)
+          .with_message("Cannot update the source language")
+      end
     end
-    it "should not raise an error and update the resource translation" do
-      options = {:i18n_type => "YAML", :content => get_yaml_source_trad_file_path('fr')}
-      expect{ @resource.translation('fr').update(options) }.to_not raise_error
+
+    it "should update the resource translation" do
+      options = {i18n_type: "YAML", content: get_yaml_source_trad_file_path("en")}
+
+      VCR.use_cassette "resource/update_translation_for_language" do
+        expect(resource.translation("en").update(options)).to eq updated_translations
+      end
     end
   end
-end
+end

data/spec/lib/transifex/translation_string_spec.rb

@@ -1,33 +1,39 @@
-require_relative "../../spec_helper"
+require "spec_helper"
 
-describe Transifex::ResourceComponents::TranslationComponents::String do 
-  before(:all) do
-    @project = Transifex::Project.new("projet-de-test-1")
-    @resource = @project.resource("test")
-  end
+describe Transifex::ResourceComponents::TranslationComponents::String do
+  let(:project) { Transifex::Project.new("ruby-client") }
+  let(:resource) { project.resource("test") }
 
-  describe "Instanciation" do
-    it "should raise an error when no parameters given" do
-      expect{ Transifex::ResourceComponents::TranslationComponents::String.new }.to raise_error(Transifex::MissingParametersError)
+  describe "Instantiation" do
+    it "should raise an error if the translation key is not provided" do
+      expect { Transifex::ResourceComponents::TranslationComponents::String.new }
+        .to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: translation_key")
     end
   end
 
   describe "Fetch" do
-    it "should raise an error if no key provided" do
-      expect{ retrieved_details = @resource.translation('en').string.fetch }.to raise_error(Transifex::MissingParametersError)
+    it "should raise an error if the key is not provided" do
+      expect { resource.translation("en").string.fetch }
+        .to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: key")
     end
-    it "should not raise an error and retrieve the details of the string" do
-      retrieved_details = nil
-      expect{ retrieved_details = @resource.translation('en').string('routes.mercury_editor').fetch }.to_not raise_error
-      expect(retrieved_details).to be_a_kind_of(Hash)
-      expect(retrieved_details.keys).to contain_exactly("comment", "context", "tags", "character_limit", "user", "key", "reviewed", "pluralized", "source_string", "translation", "last_update", "occurrences")
+
+    it "retrieve the details of the string" do
+      VCR.use_cassette "translation/fetch_string" do
+        expect(resource.translation("en").string("test_string").fetch).to eq string_details
+      end
     end
   end
 
   describe "Update" do
-    it "should not raise an error and update the specified translation string" do
-      params = {:reviewed => true, :translation => "Pouet"}
-      expect{ @resource.translation('fr').string('routes.mercury_editor').update(params) }.to_not raise_error
+    it "update the specified translation string" do
+      params = {reviewed: true, translation: "translated test string"}
+
+      VCR.use_cassette "translation/update_string" do
+        expect(resource.translation("en").string("test_string").update(params)).to eq "OK"
+        expect(resource.translation("en").string("test_string").fetch["translation"]).to eq params[:translation]
+      end
     end
   end
-end
+end

data/spec/lib/transifex/translation_strings_spec.rb

@@ -1,57 +1,79 @@
-require_relative "../../spec_helper"
+require "spec_helper"
 
-describe Transifex::ResourceComponents::TranslationComponents::Strings do 
-  before(:all) do
-    @project = Transifex::Project.new("projet-de-test-1")
-    @resource = @project.resource("test")
-  end
+describe Transifex::ResourceComponents::TranslationComponents::Strings do
+  let(:project) { Transifex::Project.new("ruby-client") }
+  let(:resource) { project.resource("test") }
 
-  describe "Instanciation" do
-    it "should raise an error when no parameters given" do
-      expect{ Transifex::ResourceComponents::TranslationComponents::Strings.new }.to raise_error(Transifex::MissingParametersError)
+  describe "Instantiation" do
+    it "should raise an error if the project_slug is not provided" do
+      expect { Transifex::ResourceComponents::TranslationComponents::Strings.new }
+        .to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: project_slug")
     end
   end
 
   describe "Fetch" do
-    it "should not raise an error and retrieve the strings of the translation without details" do
-      retrieved_strings = nil
-      expect{ retrieved_strings = @resource.translation('en').strings.fetch }.to_not raise_error
-      expect(retrieved_strings).to be_a_kind_of(Array)
-      expect(retrieved_strings.first.keys).to contain_exactly("comment", "context", "key", "reviewed", "pluralized", "source_string", "translation")
-    end
-    it "should not raise an error and retrieve the strings of the translation with details" do
-      retrieved_strings = nil
-      expect{ retrieved_strings = @resource.translation('en').strings.fetch_with_details }.to_not raise_error
-      expect(retrieved_strings).to be_a_kind_of(Array)
-      expect(retrieved_strings.first.keys).to contain_exactly("comment", "context", "tags", "character_limit", "user", "key", "reviewed", "pluralized", "source_string", "translation", "last_update", "occurrences")
-    end
-    it "should not raise an error and retrieve the strings of the translation with the key" do
-      retrieved_strings = nil
-      options = {:key => "routes.mercury_editor"}
-      expect{ retrieved_strings = @resource.translation('en').strings.fetch_with_details(options) }.to_not raise_error
-      expect(retrieved_strings).to be_a_kind_of(Array)
-      expect(retrieved_strings.first.keys).to contain_exactly("comment", "context", "tags", "character_limit", "user", "key", "reviewed", "pluralized", "source_string", "translation", "last_update", "occurrences")
-    end
-    it "should not raise an error and return an empty hash if researched context doesn't exist" do
-      retrieved_strings = nil
-      options = {:context => "notexist"}
-      expect{ retrieved_strings = @resource.translation('en').strings.fetch(options) }.to_not raise_error
-      expect(retrieved_strings).to be_a_kind_of(Array)
-      empty_array = retrieved_strings.empty?      
-      expect(empty_array).to eq(true)
+    describe "#fetch" do
+      it "retrieves the translations of all the strings of a resource for a certain language" do
+        VCR.use_cassette "translation/fetch_strings" do
+          expect(resource.translation("en").strings.fetch).to eq language_strings
+        end
+      end
+    end
+
+    describe "#fetch_with_details" do
+      it "retrieves the detailed translations of all the strings of a resource for a certain language" do
+        VCR.use_cassette "translation/fetch_with_details_strings" do
+          expect(resource.translation("en").strings.fetch_with_details).to eq language_strings_with_details
+        end
+      end
+    end
+
+    it "retrieves the strings of the translation passing the key as an option" do
+      options = {key: "test_string"}
+
+      VCR.use_cassette "translation/fetch_with_details_and_key_strings" do
+        expect(resource.translation("en").strings.fetch_with_details(options)).to eq language_strings_with_details
+      end
+    end
+
+    it "returns an empty hash if the specified context doesn't exist" do
+      options = {context: "non_existing_context"}
+
+      VCR.use_cassette "translation/fetch_with_details_and_context_strings" do
+        expect(resource.translation("en").strings.fetch(options)).to eq []
+      end
     end
   end
 
   describe "Update" do
-    it "should raise an error if the key parameter is not provided" do
-      expect{ @resource.translation('fr').strings.update({:translation => "lol"}) }.to raise_error(Transifex::MissingParametersError)
+    it "should raise an error if the key is not provided" do
+      VCR.use_cassette "translation/update_without_key_string" do
+        expect { resource.translation("en").strings.update(translation: "no key") }
+        .to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: key")
+      end
     end
-    it "should not raise an error and update the specified translation string" do
-      expect{ @resource.translation('fr').strings.update({:key => "routes.mercury_editor", :translation => "lol"}) }.to_not raise_error
+
+    it "updates the translation string for the resource for a certain language" do
+      params = {key: "test_string", translation: "updated translation"}
+
+      VCR.use_cassette "translation/update_single_translation_strings" do
+        expect(resource.translation("en").strings.update(params)).to eq "OK"
+        expect(resource.translation("en").string(params[:key]).fetch["translation"]).to eq params[:translation]
+      end
     end
-    it "should not raise an error and update multiple translation strings" do
-      params = [{:key => "routes.mercury_editor", :context => "", :translation => "lol"}, {:key => "date.abbr_day_names", :translation => "lol"}]
-      expect{ @resource.translation('fr').strings.update(params) }.to_not raise_error
+
+    it "updates multiple translation strings" do
+      params = [
+        {key: "test_string", translation: "multiple translations"},
+        {key: "yet_another_string", translation: "yet another translation"}
+      ]
+
+      VCR.use_cassette "translation/update_multiple_translation_strings" do
+        expect(resource.translation("en").strings.update(params)).to eq "OK"
+        expect(resource.translation("en").strings.fetch).to eq multiple_language_strings
+      end
     end
   end
-end
+end