transifex-interface-ruby 0.0.1 → 0.0.2

data/spec/lib/transifex/project_spec.rb

@@ -1,91 +1,64 @@
-require_relative '../../spec_helper'
+require "spec_helper"
 
-describe Transifex::Project do 
-  
+describe Transifex::Project do
   describe "Manage a project" do
-    before(:all) do
-      @correct_params_private = {:slug => "projet_private", :name => "Projet de test Private", :description => "description", :source_language_code => "en", :private => true}
-      @correct_params_public = {:slug => "projet_public", :name => "Projet de test Public", :description => "description", :source_language_code => "en", :repository_url => "http://en.google.com"} 
-      @private_project = Transifex::Projects.create(@correct_params_private)
-      @public_project = Transifex::Projects.create(@correct_params_public)  
-    end    
+    let(:project) { Transifex::Project.new("private-ruby-client") }
 
-    describe "instanciation" do
+    describe "Instanciation" do
       it "should raise an error if a slug is not provided" do
         expect { Transifex::Project.new }.to raise_error(Transifex::MissingParametersError)
+          .with_message("The following attributes are missing: You must provide a slug for a project")
       end
-    end    
+    end
 
-    context "private project" do     
-      describe "fetch" do        
-        it "should retrieve informations about the project without details" do
-          fetched_project = @private_project.fetch
-          expect { fetched_project = @private_project.fetch }.to_not raise_error          
-          expect(fetched_project).to be_a_kind_of(Hash)
-          expect(fetched_project.keys).to contain_exactly("slug", "name", "description","source_language_code")
-        end
-        it "should retrieve informations about the project with details" do
-          fetched_project = nil
-          expect { fetched_project = @private_project.fetch_with_details }.to_not raise_error
-          expect(fetched_project).to be_a_kind_of(Hash)
-          expect(fetched_project.keys).to contain_exactly("archived", "auto_join", "fill_up_resources", "homepage", "last_updated", "long_description", "maintainers", "organization", "private", "resources", "tags", "team", "teams", "trans_instructions", "slug", "name", "description","source_language_code")
+    describe "Fetch" do
+      describe "#fetch" do
+        it "should retrieve the basic info about the project" do
+          VCR.use_cassette "project/fetch_private_project_info" do
+            expect(project.fetch).to eq(private_project_info)
+          end
         end
       end
-      describe "update" do
-        it "should not raise an error and update the project" do
-          updated_project = nil
-          expect { updated_project = @private_project.update({:description => "test"}) }.to_not raise_error
-          expect(updated_project).to eq("OK")
-          fetched_project = @private_project.fetch_with_details
-          expect(fetched_project['description']).to eq('test')
-        end
-        it "should raise an error if updated field is wrong" do
-          expect { @private_project.update({:buttchick => "lol"}) }.to raise_error(Transifex::TransifexError)
-        end
-        it "should raise an error if no paramaters to update are provided" do
-          expect { @private_project.update }.to raise_error(Transifex::Error)
-        end
-      end
-      describe "delete" do
-        it "should not raise an error" do
-          expect { @private_project.delete }.to_not raise_error
+
+      describe "#fetch_with_details" do
+        it "should retrieve the complete info about the project" do
+          VCR.use_cassette "project/fetch_with_details_private_project_info" do
+            expect(project.fetch_with_details).to eq(detailed_private_project_info)
+          end
         end
       end
     end
-    context "public project" do
-      describe "fetch" do
-        it "should retrieve informations about the project without details" do
-          fetched_project = nil
-          expect { fetched_project = @public_project.fetch }.to_not raise_error
-          expect(fetched_project).to be_a_kind_of(Hash)
-          expect(fetched_project.keys).to contain_exactly("slug", "name", "description","source_language_code")
-        end
-        it "should retrieve informations about the project with details" do
-          fetched_project = nil
-          expect { fetched_project = @public_project.fetch_with_details }.to_not raise_error
-          expect(fetched_project).to be_a_kind_of(Hash)
-          expect(fetched_project.keys).to contain_exactly("archived", "auto_join", "fill_up_resources", "homepage", "last_updated", "long_description", "maintainers", "organization", "private", "resources", "tags", "team", "teams", "trans_instructions", "slug", "name", "description","source_language_code")
+
+    describe "Update" do
+      it "updates the project info" do
+        VCR.use_cassette "project/update_private_project" do
+          expect(project.update(description: "my new description")).to eq("OK")
+          expect(project.fetch_with_details).to include({"description" => "my new description"})
         end
       end
-      describe "update" do
-        it "should not raise an error and update the project" do
-          updated_project = nil
-          expect { updated_project = @public_project.update({:description => "test"}) }.to_not raise_error
-          expect(updated_project).to eq("OK")
-        end
-        it "should raise an error if updated field is wrong" do
-          updated_project = nil
-          expect { updated_project = @public_project.update({:buttchick => "lol"}) }.to raise_error(Transifex::TransifexError)
+
+      it "should raise an error if the field to be updated is not allowed" do
+        VCR.use_cassette "project/update_non_existing_attribute_private_project" do
+          expect { project.update({non_existing_attribute: "blah"}) }.to raise_error(Transifex::TransifexError)
+            .with_message("Field 'non_existing_attribute' is not allowed.")
         end
-        it "should raise an error if no paramaters to update are provided" do
-          expect { @public_project.update }.to raise_error(Transifex::Error)
+      end
+
+      it "should raise an error if no paramaters to update are provided" do
+        VCR.use_cassette "project/update_with_missing_params_private_project" do
+          expect { project.update }.to raise_error(Transifex::Error)
+            .with_message("Empty request")
         end
       end
-      describe "delete"  do
-        it "should not raise an error" do
-          expect { @public_project.delete }.to_not raise_error
-        end        
+    end
+
+    describe "Delete" do
+      it "should delete the project" do
+        VCR.use_cassette "project/delete_project" do
+          expect(project.delete).to be nil
+          expect { project.fetch }.to raise_error(Transifex::TransifexError).with_message("Not Found")
+        end
       end
-    end    
-  end  
-end
+    end
+  end
+end

data/spec/lib/transifex/projects_spec.rb

@@ -1,48 +1,83 @@
-require_relative "../../spec_helper"
+require "spec_helper"
 
-describe Transifex::Projects do 
-  before(:all) do
-    @incorrect_params = {:slug => "test"}
-    @correct_params_private = {:slug => "projet_de_test_private", :name => "Projet de test Public", :description => "description", :source_language_code => "en", :private => true}
-    @correct_params_public = {:slug => "projet_de_test_public", :name => "Projet de test Private", :description => "description", :source_language_code => "en", :repository_url => "http://en.google.com"} 
-  end
+describe Transifex::Projects do
+
+  describe "Create" do
+    it "should raise an error if parameters are missing" do
+      expect { Transifex::Projects.create(slug: "private-ruby-client") }
+        .to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: name, description, source_language_code, repository_url, private")
+    end
+
+    it "creates a private project" do
+      params = {
+        slug: "private-ruby-client",
+        name: "Private Ruby Client",
+        description: "Private Ruby Client",
+        source_language_code: "eo",
+        private: true
+      }
 
-  describe "create" do 
-    it "should raise an error if required parameters are missing" do
-      expect { Transifex::Projects.create(@incorrect_params) }.to raise_error(Transifex::MissingParametersError)
-    end 
-    context "private project" do
-      it "should not raise an error if required parameters are provided and create the private project" do
-        created_project = nil
-        expect { created_project = Transifex::Projects.create(@correct_params_private) }.to_not raise_error
-        expect(created_project).to be_a_kind_of(Transifex::Project)
-        expect(created_project.project_slug).to eq(@correct_params_private[:slug])
-        created_project.delete
+      VCR.use_cassette "projects/create_private_project" do
+        project = Transifex::Projects.create(params)
+
+        expect(project.project_slug).to eq(params[:slug])
+        expect(Transifex::Project.new(params[:slug]).fetch).to eq(private_project_info)
       end
     end
-    context "public project" do
-      it "should not raise an error if required parameters are provided and create the project" do
-        created_project = nil
-        expect { created_project = Transifex::Projects.create(@correct_params_public) }.to_not raise_error
-        expect(created_project).to be_a_kind_of(Transifex::Project)
-        expect(created_project.project_slug).to eq(@correct_params_public[:slug])
-        created_project.delete
+
+    it "raises an error if a project with the same slug already exists" do
+      params = {
+        slug: "private-ruby-client",
+        name: "Private Ruby Client",
+        description: "Private Ruby Client",
+        source_language_code: "eo",
+        private: true
+      }
+
+      VCR.use_cassette "projects/create_used_slug_project" do
+        expect { Transifex::Projects.create(params) }.to raise_error(Transifex::TransifexError)
+          .with_message("[u\"[('slug', [u'Project with this Slug already exists.'])]\"]")
       end
-      it "should raise an error if repository_url is not matching the correct format" do
-        incorrect_params_public = @correct_params_public
-        incorrect_params_public[:repository_url] = "www.google.com"
-        expect { Transifex::Projects.create(@correct_params_public) }.to raise_error(Transifex::ParametersFormatError)
+    end
+
+    it "creates a public project" do
+      params = {
+        slug: "public-ruby-client",
+        name: "Public Ruby Client",
+        description: "Public Ruby Client",
+        source_language_code: "it",
+        repository_url: "http://valid.url.it"
+      }
+
+      VCR.use_cassette "projects/create_public_project" do
+        project = Transifex::Projects.create(params)
+
+        expect(project.project_slug).to eq(params[:slug])
+        expect(Transifex::Project.new(params[:slug]).fetch).to eq(public_project_info)
       end
     end
+
+    it "should raise an error if repository_url is not matching the requested format" do
+      params = {
+        slug: "public-ruby-client",
+        name: "Public Ruby Client",
+        description: "Public Ruby Client",
+        source_language_code: "it",
+        repository_url: "http://not-valid.url"
+      }
+
+      expect { Transifex::Projects.create(params) }
+        .to raise_error(Transifex::ParametersFormatError)
+        .with_message("The following parameter: repository_url must follow the format: http|https|ftp://x.x.x")
+    end
   end
+
   describe "Fetch" do
-    it "should not raise an error and return an array of hash" do
-      fetched_projects = nil
-      expect{ fetched_projects = Transifex::Projects.fetch}.to_not raise_error
-      expect(fetched_projects).to be_a_kind_of(Array)
-      expect(fetched_projects).not_to match_array([]) 
-      expect(fetched_projects.first).to be_a_kind_of(Hash)
-      expect(fetched_projects.first.keys).to contain_exactly("slug", "name", "description","source_language_code")
+    it "retrieves the projects as an array of hashes, one for each project" do
+      VCR.use_cassette "projects/fetch_projects" do
+        expect(Transifex::Projects.fetch).to eq(all_projects_info)
+      end
     end
   end
-end
+end

data/spec/lib/transifex/resource_content_spec.rb

@@ -1,40 +1,57 @@
-require_relative "../../spec_helper"
+require "spec_helper"
 
-describe Transifex::ResourceComponents::Content do 
-  before(:all) do
-    @project = Transifex::Project.new("projet-de-test-1")
-    @resource = @project.resource("test")
-  end
+describe Transifex::ResourceComponents::Content 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
+  describe "Instantiation" do
+    it "should raise an error when no parameters are given" do
       expect{ Transifex::ResourceComponents::Content.new }.to raise_error(ArgumentError)
     end
   end
 
   describe "Fetch" do
     it "should retrieve the resource content as a hash" do
-      resource_content = nil
-      expect{ resource_content = @resource.content.fetch }.to_not raise_error
-      expect(resource_content).to be_a_kind_of(Hash)
-      expect(resource_content.keys).to contain_exactly("content", "mimetype")
-    end 
+      VCR.use_cassette "resource/fetch_content_as_hash" do
+        expect(resource.content.fetch).to eq resource_content_hash
+      end
+    end
 
     it "should retrieve the resource content as a file" do
-      resource_content = nil
-      path_to_file = File.dirname(__FILE__) + "/../yaml/resource_content_test.yml"
-      expect{ resource_content = @resource.content.fetch_with_file(path_to_file) }.to_not raise_error
-      file_exist = File.file?(path_to_file)
-      expect(file_exist).to eq(true)
-    end 
+      VCR.use_cassette "resource/fetch_content_as_file" do
+        resource.content.fetch_with_file("fetched.yml")
+      end
+
+      expect(File.exist?("fetched.yml")).to be true
+    end
   end
 
   describe "Update" do
-    it "should not raise an error and update the resource content" do
-      expect{ @resource.content.update({:i18n_type => "YAML", :content => get_yaml_source_trad_file_path('en')}) }.to_not raise_error
+    it "updates a resource using a file" do
+      params = { i18n_type: "YAML", content: get_yaml_source_trad_file_path("eo") }
+      options = { trad_from_file: true }
+
+      VCR.use_cassette "resource/update_content_yml" do
+        expect(resource.content.update(params, options))
+          .to eq updated_resource_with_file
+      end
     end
-    it "should raise an error if updated resource content is of a different type than the previous" do
-      expect{ @resource.content.update({:i18n_type => "TXT", :content => get_yaml_source_trad_file_path('en')}) }.to raise_error(Transifex::Error)
+
+    it "updates a resource using json" do
+      json_resource = project.resource("json")
+      params = {i18n_type: "KEYVALUEJSON", content: {test_string: 'test string as json'}}
+
+      VCR.use_cassette "resource/update_content_json" do
+        expect(json_resource.content.update(params))
+          .to eq updated_resource_with_json
+      end
+    end
+
+    it "should raise an error if the mime type of the resource to be updated is different than the one defined in the project for the resource" do
+      VCR.use_cassette "resource/update_content_with_wrong_mimetype" do
+        expect { resource.content.update(i18n_type: "TXT", content: "") }.to raise_error(Transifex::Error)
+          .with_message("You must use the mimetype YML to upload a new resource file")
+      end
     end
   end
-end
+end

data/spec/lib/transifex/resource_source_spec.rb

@@ -1,30 +1,32 @@
-require_relative "../../spec_helper"
+require "spec_helper"
 
-describe Transifex::ResourceComponents::Source do 
-  before(:all) do
-    @project = Transifex::Project.new("projet-de-test-1")
-    @resource = @project.resource("test")
-  end
+describe Transifex::ResourceComponents::Source do
+  let(:project) { Transifex::Project.new("ruby-client") }
+  let(:resource) { project.resource("json") }
 
-  describe "Instanciation" do
-    it "should raise an error when no parameters given" do
-      expect{ Transifex::ResourceComponents::Source.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::Source.new }.to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: project_slug")
     end
   end
 
   describe "Fetch" do
-    it "should retrieve the resource source string details as a hash" do
-      source_string_details = nil
-      expect{ source_string_details = @resource.source("routes.mercury_editor").fetch }.to_not raise_error
-      expect(source_string_details).to be_a_kind_of(Hash)
-      expect(source_string_details.keys).to contain_exactly("comment", "character_limit", "tags")
-    end 
+    it "should retrieve the meta-data of a resource source string" do
+      VCR.use_cassette "resource/fetch_source_string_metadata" do
+        expect(resource.source("content.update_string").fetch).to eq resource_source_string_metadata
+      end
+    end
   end
 
   describe "Update" do
-    it "should not raise an error and update the source string details" do
-      params = {:comment => "test", :character_limit => 140, :tags => ["tag1", "tag2"]}
-      expect{ @resource.source("routes.mercury_editor").update(params) }.to_not raise_error
+    it "should update the meta-data of a resource source string" do
+      params = {comment: "my comment", character_limit: 140, tags: ["tag1", "tag2"]}
+
+      VCR.use_cassette "resource/update_source_string_metadata" do
+        expect(resource.source("content.update_string").update(params)).to eq "OK"
+        expect(resource.source("content.update_string").fetch).to eq updated_resource_source_string_metadata
+      end
     end
   end
-end
+end

data/spec/lib/transifex/resource_spec.rb

@@ -1,66 +1,94 @@
-require_relative '../../spec_helper'
+require "spec_helper"
 
-describe Transifex::Resource do  
+describe Transifex::Resource do
+  let(:project) { Transifex::Project.new("ruby-client") }
 
-  before(:all) do
-    @correct_params_public = {:slug => "resource_test_project", :name => "Projet de test resource", :description => "description", :source_language_code => "en", :repository_url => "http://en.google.com"} 
-    @project = Transifex::Projects.create(@correct_params_public)
-    @project.resources.create({:slug => "resource_test", :name => "resource_test", :i18n_type => "TXT", :content => "test"})   
-  end
+  describe "Instantiation" do
+    it "should raise an error if the project_slug is not provided" do
+      expect { Transifex::Resource.new }.to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: project_slug")
+    end
 
-  it "should raise an error if project slug or Resource slug are not provided" do
-    expect{ Transifex::Resource.new(nil, "test") }.to raise_error(Transifex::MissingParametersError)
-    expect{ Transifex::Resource.new("test", nil) }.to raise_error(Transifex::MissingParametersError)
+    it "should raise an error if the resource_slug is not provided" do
+      expect { Transifex::Resource.new("test", nil) }.to raise_error(Transifex::MissingParametersError)
+        .with_message("The following attributes are missing: resource_slug")
+    end
   end
 
   describe "Fetch" do
-    it "should raise an error if resource doesn't exist" do
-      expect{ @project.resource("wrong_slug").fetch }.to raise_error(Transifex::Error)
+    it "should raise an error if the resource doesn't exist" do
+      VCR.use_cassette "resource/fetch_not_existing_resource" do
+        expect { project.resource("not_existing_resource").fetch }.to raise_error(Transifex::Error)
+          .with_message("Not Found")
+      end
     end
 
-    it "should not raise an error and retrieve the correct infos without details" do
-      fetched_resource = nil
-      expect{ fetched_resource = @project.resource("resource_test").fetch }.to_not raise_error
-      expect(fetched_resource).to be_a_kind_of(Hash)
-      expect(fetched_resource.keys).to contain_exactly("source_language_code", "name", "i18n_type", "priority", "slug", "categories")
+    describe "#fetch" do
+      it "should retrieve the basic info for the resource" do
+        resource = project.resource("json")
+
+        VCR.use_cassette "resource/fetch_resource_info" do
+          expect(resource.fetch).to eq basic_resource_info
+        end
+      end
     end
 
-    it "should not raise an error and retrieve the correct infos with details" do
-      fetched_resource = nil
-      expect{ fetched_resource = @project.resource("resource_test").fetch_with_details }.to_not raise_error
-      expect(fetched_resource).to be_a_kind_of(Hash)
-      expect(fetched_resource.keys).to contain_exactly("source_language_code", "name", "created", "wordcount", "i18n_type", "project_slug", "accept_translations", "last_update", "priority", "available_languages", "total_entities", "slug", "categories")
+    describe "#fetch_with_details" do
+      it "should retrieve the complete info for the resource" do
+        resource = project.resource("json")
+
+        VCR.use_cassette "resource/fetch_with_details_resource_info" do
+          expect(resource.fetch_with_details).to eq detailed_resource_info
+        end
+      end
     end
   end
 
   describe "Update" do
-    it "should raise an error if resource doesn't exist" do
-      expect{ @project.resource("wrong_slug").update }.to raise_error(Transifex::Error)
+    it "should raise an error if the resource doesn't exist" do
+      params = {name: "new name"}
+
+      VCR.use_cassette "resource/update_not_existing_resource" do
+        expect { project.resource("not_existing_resource").update(params) }.to raise_error(Transifex::Error)
+          .with_message("Not Found")
+      end
     end
 
-    it "should update multiple attributes" do
-      expect{ fetched_resource = @project.resource("resource_test").update({name: "new_name", categories: ["test1", "test2"]}) }.to_not raise_error
-      fetched_resource = @project.resource("resource_test").fetch
-      expect(fetched_resource['name']).to eq("new_name")
-      expect(fetched_resource['categories']).to be_a_kind_of(Array)
-      expect(fetched_resource['categories'].join(',')).to eq("test1,test2")
+    it "should update the resource when given multiple changes" do
+      resource = project.resource("test")
+
+      params = {name: "updated name", categories: ["test1", "test2"]}
+
+      VCR.use_cassette "resource/update_resource_info" do
+        expect(resource.update(params)).to eq "OK"
+
+        expect(resource.fetch).to eq updated_resource_info
+      end
     end
   end
 
   describe "Delete" do
-    it "should raise an error if resource doesn't exist" do
-      expect{ @project.resource("wrong_slug").delete }.to raise_error(Transifex::Error)
+    it "should raise an error if the resource doesn't exist" do
+      VCR.use_cassette "resource/delete_not_existing_resource" do
+        expect { project.resource("not_existing_resource").delete }.to raise_error(Transifex::Error)
+          .with_message("Not Found")
+      end
     end
 
     it "should delete a resource" do
-      @project.resources.create({:slug => "resource_delete_test", :name => "resource_delete_test", :i18n_type => "TXT", :content => "test"})
-      expect{ @project.resource("resource_delete_test").fetch }.to_not raise_error
-      expect{ @project.resource("resource_delete_test").delete }.to_not raise_error
-      expect{ @project.resource("resource_delete_test").fetch }.to raise_error
-    end
-  end
+      VCR.use_cassette "resource/delete_resource" do
+        project.resources.create(
+          slug: "resource_to_be_deleted",
+          name: "Resource to be deleted",
+          i18n_type: "TXT",
+          content: "nothing to see here"
+        )
+
+        expect(project.resource("resource_to_be_deleted").delete).to be nil
 
-  after(:all) do
-    @project.delete
+        expect { project.resource("resource_to_be_deleted").fetch }.to raise_error(Transifex::Error)
+          .with_message("Not Found")
+      end
+    end
   end
-end
+end