gooddata 0.6.15 → 0.6.16

data/lib/gooddata/rest/client.rb

@@ -224,8 +224,7 @@ module GoodData
         @connection.get uri, opts, & block
       end
 
-      # FIXME: Invstigate _file argument
-      def get_project_webdav_path(_file, opts = { :project => GoodData.project })
+      def project_webdav_path(opts = { :project => GoodData.project })
         p = opts[:project]
         fail ArgumentError, 'No :project specified' if p.nil?
 
@@ -236,8 +235,7 @@ module GoodData
         URI.join(u.to_s.chomp(u.path.to_s), '/project-uploads/', "#{project.pid}/")
       end
 
-      # FIXME: Invstigate _file argument
-      def get_user_webdav_path(_file, opts = { :project => GoodData.project })
+      def user_webdav_path(opts = { :project => GoodData.project })
         p = opts[:project]
         fail ArgumentError, 'No :project specified' if p.nil?
 

data/lib/gooddata/rest/connection.rb

@@ -12,6 +12,7 @@ module GoodData
       DEFAULT_URL = 'https://secure.gooddata.com'
       LOGIN_PATH = '/gdc/account/login'
       TOKEN_PATH = '/gdc/account/token'
+      KEYS_TO_SCRUB = [:password, :verifyPassword, :authorizationToken]
 
       DEFAULT_HEADERS = {
         :content_type => :json,
@@ -258,7 +259,7 @@ module GoodData
       # @param uri [String] Target URI
       def put(uri, data, options = {})
         payload = data.is_a?(Hash) ? data.to_json : data
-        GoodData.logger.debug "PUT: #{@server.url}#{uri}, #{scrub_params(data, [:password, :login, :authorizationToken])}"
+        GoodData.logger.debug "PUT: #{@server.url}#{uri}, #{scrub_params(data, KEYS_TO_SCRUB)}"
         profile "PUT #{uri}" do
           b = proc { @server[uri].put payload, cookies }
           process_response(options, &b)
@@ -269,7 +270,7 @@ module GoodData
       #
       # @param uri [String] Target URI
       def post(uri, data, options = {})
-        GoodData.logger.debug "POST: #{@server.url}#{uri}, #{scrub_params(data, [:password, :login, :authorizationToken])}"
+        GoodData.logger.debug "POST: #{@server.url}#{uri}, #{scrub_params(data, KEYS_TO_SCRUB)}"
         profile "POST #{uri}" do
           payload = data.is_a?(Hash) ? data.to_json : data
           b = proc { @server[uri].post payload, cookies }

data/lib/gooddata/version.rb

@@ -2,7 +2,7 @@
 
 # GoodData Module
 module GoodData
-  VERSION = '0.6.15'
+  VERSION = '0.6.16'
 
   class << self
     # Version

data/spec/helpers/project_helper.rb

@@ -16,7 +16,7 @@ module ProjectHelper
     GoodData::Project[PROJECT_ID, opts]
   end
 
-  def self.delete_old_projects(opts = {:client => GoodData.connection})
+  def self.delete_old_projects(opts = { :client => GoodData.connection })
     projects = opts[:client].projects
     projects.each do |project|
       next if project.json['project']['meta']['author'] != client.user.uri

data/spec/integration/project_spec.rb

@@ -52,15 +52,15 @@ describe GoodData::Project, :constraint => 'slow' do
       end
       @domain.create_users(users.map {|u| u[:user]})
       res = @project.add_users(users, domain: @domain)
-      links = res.map {|i| i[:result]['projectUsersUpdateResult']['successful'].first}
+      links = res.map {|i| i[:uri]}
       expect(@project.members?(links).all?).to be_truthy
-      # users.map { |r| r[:user] }.each { |u| u.delete }
     end
   end
 
   describe '#import_users' do
     it "Updates user's name and surname and removes the users" do
       users = (1..2).to_a.map { |x| ProjectHelper.create_random_user(@client) }
+      @domain.create_users(users)
       @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
       expect(@domain.members?(users)).to be_truthy
       expect(@project.members?(users)).to be_truthy
@@ -70,6 +70,7 @@ describe GoodData::Project, :constraint => 'slow' do
       bill.first_name = 'buffalo'
       bill.last_name = 'bill'
       # import
+      @domain.create_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
       @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
       # it should be updated
       bill_changed = @domain.get_user(bill)
@@ -88,16 +89,19 @@ describe GoodData::Project, :constraint => 'slow' do
       # Add additional user while changing Buffalos surname and role.
       bill.last_name = 'Billie'
       other_guy = ProjectHelper.create_random_user(@client)
+      additional_batch = [bill, other_guy]
+
+      @domain.create_users(additional_batch, domain: @domain)
+      @project.import_users(additional_batch.map { |u| {user: u, role: u.role} }, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
 
-      additional_batch = [bill, other_guy].map { |u| {user: u, role: u.role} }
-      @project.import_users(additional_batch, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
       expect(@project.members.count).to eq 3
       expect(@project.member?(bill)).to be_truthy
-      expect(@project.members?(users - additional_batch.map {|x| x[:user]}).any?).to be_falsey
+      expect(@project.members?(users - additional_batch).any?).to be_falsey
     end
 
     it "Updates user's role in a project" do
       users = (1..5).to_a.map { |x| ProjectHelper.create_random_user(@client).to_hash }
+      @domain.create_users(users, domain: @domain)
       @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
 
       expect(@project.members?(users)).to be_truthy
@@ -115,6 +119,7 @@ describe GoodData::Project, :constraint => 'slow' do
       uh[:role] = 'editor'
 
       users = (1..5).to_a.map { |x| ProjectHelper.create_random_user(@client).to_hash } + [uh]
+      @domain.create_users(users, domain: @domain)
       expect(@project.member?(u)).to be_truthy
       expect(u.role.title).to eq 'Admin'
       @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])

data/spec/integration/rest_spec.rb

@@ -15,9 +15,9 @@ describe GoodData do
     @client.disconnect
   end
 
-  describe '#get_project_webdav_path' do
+  describe '#project_webdav_path' do
     it 'Returns path' do
-      @client.get_project_webdav_path('test-file.csv', :project => @project)
+      @client.project_webdav_path(:project => @project)
     end
   end
 
@@ -201,9 +201,9 @@ describe GoodData do
   end
 
 
-  describe '#get_user_webdav_path' do
+  describe '#user_webdav_path' do
     it 'Gets the path' do
-      @client.get_user_webdav_path('test.csv', :project => @project)
+      @client.user_webdav_path(:project => @project)
     end
   end
 end

data/spec/integration/user_filters_spec.rb

@@ -27,6 +27,7 @@ describe "User filters implementation", :constraint => 'slow' do
       GoodData::Model.upload_data(devs_data, blueprint, 'devs', :client => @client, :project => @project)
       # blueprint.find_dataset('devs').upload(devs_data)
     end
+
   end
 
   after(:all) do
@@ -84,7 +85,7 @@ describe "User filters implementation", :constraint => 'slow' do
     expect(@project.data_permissions.first.pretty_expression).to eq "[Dev] IN ([tomas@gooddata.com])"
   end
 
-  it "should fail when asked to set a value not in the proejct" do
+  it "should fail when asked to set a value not in the project" do
     filters = [
       [ConnectionHelper::DEFAULT_USERNAME, @label.uri, '%^&*( nonexistent value', 'tomas@gooddata.com'],
       [ConnectionHelper::DEFAULT_USERNAME, @label.uri, 'tomas@gooddata.com']]

data/spec/unit/models/metric_spec.rb

@@ -48,7 +48,7 @@ describe GoodData::Metric do
                 {'content' =>
                    {'format' => '#,##0',
                     'expression' =>
-                      "SELECT SUM([#{USED_METRIC.uri})"},
+                      "SELECT SUM([#{USED_METRIC.uri}])"},
                  'meta' =>
                    {'author' => '/gdc/account/profile/4e1e8cacc4989228e0ae531b30853248',
                     'uri' => '/gdc/md/ksjy0nr3goz6k8yrpklz97l0mych7nez/obj/252',
@@ -69,27 +69,27 @@ describe GoodData::Metric do
 
   describe '#contain?' do
     it 'should say it contains a depending metric if it does' do
-      @instance.contain?(USED_METRIC).should == true
+      expect(@instance.contain?(USED_METRIC)).to eq true
     end
 
     it 'should say it contains a depending object which is given as a string if it does' do
-      @instance.contain?(USED_METRIC).should == true
+      expect(@instance.contain?(USED_METRIC)).to eq true
     end
 
     it 'should be able to replace an object if the object is used in the expression' do
-      pending('resolve mutating constant if I init from it')
+      skip('resolve mutating constant if I init from it')
     end
 
     it 'should be able to return an expression of the metric' do
-      @instance.expression.should == "SELECT SUM([#{USED_METRIC.uri})"
+      expect(@instance.expression).to eq "SELECT SUM([#{USED_METRIC.uri}])"
     end
 
     it 'should be able to replace an object if the object is used in the expression' do
-      @instance.contain?(USED_METRIC).should == true
-      @instance.contain?(UNUSED_METRIC).should == false
+      expect(@instance.contain?(USED_METRIC)).to be_truthy
+      expect(@instance.contain?(UNUSED_METRIC)).to be_falsey
       @instance.replace(USED_METRIC, UNUSED_METRIC)
-      @instance.contain?(USED_METRIC).should == false
-      @instance.contain?(UNUSED_METRIC).should == true
+      expect(@instance.contain?(USED_METRIC)).to be_falsey
+      expect(@instance.contain?(UNUSED_METRIC)).to be_truthy
     end
   end
 

data/spec/unit/models/project_spec.rb

@@ -1,6 +1,5 @@
 # encoding: UTF-8
 
-require 'pmap'
 require 'gooddata'
 
 describe GoodData::Project, :constraint => 'slow' do
@@ -146,19 +145,6 @@ describe GoodData::Project, :constraint => 'slow' do
     end
   end
 
-  # describe '#processes' do
-  #   it 'Returns the processes' do
-  #     @project.deploy_process('./spec/data/ruby_process',
-  #                                   type: 'RUBY',
-  #                                   name: 'Test ETL Process')
-  #     processes = @project.processes
-  #     expect(processes).to be_a_kind_of(Array)
-  #     binding.pry
-  #     expect(processes.count).to eq 1
-  #     expect(processes.map(&:project).uniq).to eq [@project]
-  #   end
-  # end
-
   describe '#roles' do
     it 'Returns array of GoodData::ProjectRole' do
       roles = @project.roles
@@ -169,262 +155,4 @@ describe GoodData::Project, :constraint => 'slow' do
       end
     end
   end
-
-  # describe '#users' do
-  #   it 'Returns array of GoodData::Users' do
-  # 
-  #     invitations = @project.invitations
-  #     expect(invitations).to_not be_nil
-  #     expect(invitations).to be_instance_of(Array)
-  # 
-  #     users = @project.users
-  #     expect(users).to be_instance_of(Array)
-  # 
-  #     users.each do |user|
-  #       expect(user).to be_instance_of(GoodData::Membership)
-  # 
-  #       roles = user.roles
-  #       expect(roles).to_not be_nil
-  #       expect(roles).to be_instance_of(Array)
-  # 
-  #       roles.each do |role|
-  #         expect(role).to be_instance_of(GoodData::ProjectRole)
-  #       end
-  # 
-  #       permissions = user.permissions
-  #       expect(permissions).to_not be_nil
-  #       expect(permissions).to_not be_nil
-  #       expect(permissions).to be_instance_of(Hash)
-  # 
-  #       # invitations = user.invitations
-  #       # invitations.should_not be_nil
-  # 
-  #       if (user.email == 'tomas.korcak@gooddata.com')
-  #         projects = user.projects
-  #         expect(projects).to_not be_nil
-  #         expect(projects).to be_instance_of(Array)
-  # 
-  #         projects.each do |project|
-  #           expect(project).to be_instance_of(GoodData::Project)
-  #         end
-  #       end
-  #     end
-  #   end
-  # end
-  # 
-  # describe '#add_user' do
-  #   it 'Adding user without domain should fail if it is not in the project' do
-  #     user = ProjectHelper.create_random_user(@client)
-  #     expect do
-  #       @project.add_user(user, 'Admin')
-  #     end.to raise_exception(ArgumentError)
-  #   end
-  # 
-  #   it 'Adding user with domain should be added to a project' do
-  #     user = ProjectHelper.create_random_user(@client)
-  #     @domain.create_users([user])
-  #     res = @project.add_user(user, 'Admin', domain: @domain)
-  #     expect(@project.member?(res['projectUsersUpdateResult']['successful'].first)).to be_truthy
-  #   end
-  # end
-  # 
-  # describe '#add_users' do
-  #   it 'Adding user without domain should fail if it is not in the project' do
-  #     users = (1..5).to_a.map do |x|
-  #       {
-  #         user: ProjectHelper.create_random_user(@client),
-  #         role: 'Admin'
-  #       }
-  #     end
-  #     res = @project.add_users(users)
-  #     expect(res.all? { |x| x[:type] == :error }).to eq true
-  #   end
-  # 
-  #   it 'Adding users with domain should pass and users should be added to domain' do
-  #     users = (1..5).to_a.map do |x|
-  #       {
-  #         user: ProjectHelper.create_random_user(@client),
-  #         role: 'Admin'
-  #       }
-  #     end
-  #     @domain.create_users(users.map {|u| u[:user]})
-  #     res = @project.add_users(users, domain: @domain)
-  #     links = res.map {|i| i[:result]['projectUsersUpdateResult']['successful'].first}
-  #     expect(@project.members?(links).all?).to be_truthy
-  #     # users.map { |r| r[:user] }.each { |u| u.delete }
-  #   end
-  # end
-  # 
-  # describe '#import_users' do
-  #   it "Updates user's name and surname and removes the users" do
-  #     users = (1..2).to_a.map { |x| ProjectHelper.create_random_user(@client) }
-  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
-  #     expect(@domain.members?(users)).to be_truthy
-  #     expect(@project.members?(users)).to be_truthy
-  #     expect(@project.members.count).to eq 3
-  #     # update some user stuff
-  #     bill = users[0]
-  #     bill.first_name = 'buffalo'
-  #     bill.last_name = 'bill'
-  #     # import
-  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
-  #     # it should be updated
-  #     bill_changed = @domain.get_user(bill)
-  #     expect(bill_changed.first_name).to eql('buffalo')
-  #     expect(bill_changed.last_name).to eql('bill')
-  #     expect(@project.members?(users)).to be_truthy
-  #     expect(@project.members.count).to eq 3
-  #     expect(@project.member?(bill_changed)).to be_truthy
-  # 
-  #     # remove everybody but buffalo bill.
-  #     @project.import_users([bill], domain: @domain, whitelists: [/gem_tester@gooddata.com/])
-  #     expect(@project.members.count).to eq 2
-  #     expect(@project.member?(bill)).to be_truthy
-  #     expect(@project.members?(users - [bill]).any?).to be_falsey
-  # 
-  #     # Add additional user while changing Buffalos surname and role.
-  #     bill.last_name = 'Billie'
-  #     other_guy = ProjectHelper.create_random_user(@client)
-  # 
-  #     additional_batch = [bill, other_guy].map { |u| {user: u, role: u.role} }
-  #     @project.import_users(additional_batch, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
-  #     expect(@project.members.count).to eq 3
-  #     expect(@project.member?(bill)).to be_truthy
-  #     expect(@project.members?(users - additional_batch.map {|x| x[:user]}).any?).to be_falsey
-  #   end
-  # 
-  #   it "Updates user's role in a project" do
-  #     users = (1..5).to_a.map { |x| ProjectHelper.create_random_user(@client).to_hash }
-  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
-  # 
-  #     expect(@project.members?(users)).to be_truthy
-  #     user_role_changed = users[1]
-  #     users_unchanged = users - [user_role_changed]
-  #     new_role = users[1][:role] = users[1][:role] == "admin" ? "editor" : "admin"
-  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
-  #     expect(@project.get_user(user_role_changed).role.identifier).to eql("#{new_role}Role")
-  #     expect(users_unchanged.map {|u| @project.get_user(u)}.map(&:role).map(&:title).uniq).to eq ['Editor']
-  #   end
-  # 
-  #   it "ignores user from both project and end state batch when whitelisted" do
-  #     u = @project.get_user(ConnectionHelper::DEFAULT_USERNAME)
-  #     uh = u.to_hash
-  #     uh[:role] = 'editor'
-  # 
-  #     users = (1..5).to_a.map { |x| ProjectHelper.create_random_user(@client).to_hash } + [uh]
-  #     expect(@project.member?(u)).to be_truthy
-  #     expect(u.role.title).to eq 'Admin'
-  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
-  #     expect(@project.member?(u)).to be_truthy
-  #     expect(@project.members?(users).all?).to be_truthy
-  #     expect(@project.get_user(ConnectionHelper::DEFAULT_USERNAME).role.title).to eq 'Admin'
-  #   end
-  # 
-  # end
-  # 
-  # describe '#set_user_roles' do
-  #   it 'Properly updates user roles as needed' do
-  #     users_to_import = @domain.users.sample(5).map {|u| { user: u, role: 'admin' }}
-  #     @project.import_users(users_to_import, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
-  #     users_without_owner = @project.users.reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }.pselect { |u| u.role.title == 'Admin' }
-  # 
-  #     user_to_change = users_without_owner.sample
-  #     @project.set_user_roles(user_to_change, 'editor')
-  #     expect(user_to_change.role.title).to eq 'Editor'
-  #     @project.set_user_roles(user_to_change, 'admin')
-  #     expect(user_to_change.role.title).to eq 'Admin'
-  # 
-  #     # Try different notation
-  #     @project.set_users_roles([user: user_to_change, role: 'editor'])
-  #     expect(user_to_change.role.title).to eq 'Editor'
-  #     @project.set_users_roles([user: user_to_change, role: 'admin'])
-  #     expect(user_to_change.role.title).to eq 'Admin'
-  #   end
-  # 
-  #   it 'Properly updates user roles when user specified by email and :roles specified as array of string with role names' do
-  #     # pick non deleted users that are not owner and have other roles than admin or editor
-  #     users = @project.users
-  #     users_without_owner = users
-  #       .reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }
-  #       .reject { |u| u.login =~ /^deleted/ }
-  #       .pselect { |u| u.role.title =~ /^(Admin|Editor)/ }
-  # 
-  #     # take 10 users that we will exercise
-  #     users_to_change = users_without_owner.sample(10)
-  # 
-  #     # alternate roles and prepare structure
-  #     logins = users_to_change.map(&:login)
-  #     roles = users_to_change.map { |u| u.role.title == 'Admin' ? ['Editor'] : ['Admin'] }
-  # 
-  #     list = users_to_change.map do |u|
-  #       {
-  #         :user => u.login,
-  #         :roles => u.role.title == 'Admin' ? ['Editor'] : ['Admin']
-  #       }
-  #     end
-  # 
-  #     # set the roles
-  #     res = @project.set_users_roles(list)
-  #     expect(res.length).to equal(list.length)
-  #     expect(logins.map {|l| users.find {|u| u.login == l}}.pmap {|u| u.role.title}).to eq roles.flatten
-  #   end
-  # 
-  #   it 'Properly updates user roles when user specified by email and :roles specified as string with role name' do
-  #     users = @project.users
-  #     users_without_owner = users
-  #       .reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }
-  #       .reject(&:deleted?)
-  #       .pselect { |u| u.role.title =~ /^(Admin|Editor)/ }
-  # 
-  #     users_to_change = users_without_owner.sample(10)
-  # 
-  #     logins = users_to_change.map(&:login)
-  #     roles = users_to_change.map { |u| u.role.title == 'Admin' ? 'Editor' : 'Admin' }
-  # 
-  #     list = users_to_change.map do |u|
-  #       {
-  #         :user => u.login,
-  #         :roles => u.role.title == 'Admin' ? 'Editor' : 'Admin'
-  #       }
-  #     end
-  # 
-  #     res = @project.set_users_roles(list)
-  #     expect(res.length).to equal(list.length)
-  #     expect(logins.map {|l| users.find {|u| u.login == l}}.pmap {|u| u.role.title}).to eq roles.flatten
-  #     
-  #   end
-  # end
-  # 
-  # describe '#summary' do
-  #   it 'Properly gets summary of project' do
-  #     res = @project.summary
-  #     expect(res).to include(ProjectHelper::PROJECT_SUMMARY)
-  #   end
-  # end
-  # 
-  # describe '#title' do
-  #   it 'Properly gets title of project' do
-  #     res = @project.title
-  #     expect(res).to include(ProjectHelper::PROJECT_TITLE)
-  #   end
-  # end
-  # 
-  # describe 'enabling and disabling users' do
-  #   it 'should be able to enable and disable a user' do
-  #     users_without_owner = @project.users
-  #       .reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }
-  #       .reject(&:deleted?)
-  #       .select(&:enabled?)
-  #     user = users_without_owner.sample
-  #     expect(user.enabled?).to be_truthy
-  #     expect(user.disabled?).to be_falsey
-  #     user.disable
-  #     expect(user.disabled?).to be_truthy
-  #     expect(user.enabled?).to be_falsey
-  #     user.enable
-  #     expect(user.enabled?).to be_truthy
-  #     expect(user.disabled?).to be_falsey
-  #     expect(user.project).not_to be_nil
-  #   end
-  # end
 end