gooddata 0.6.11 → 0.6.12

data/spec/helpers/process_helper.rb

@@ -8,8 +8,8 @@ require 'pmap'
 require 'gooddata/models/models'
 
 module ProcessHelper
-  PROCESS_ID = 'dc143d80-58a1-4acd-96b6-8d11fc4571de'
-  DEPLOY_NAME = 'graph'
+  PROCESS_ID = '81fa71a4-69fd-4c58-aa09-66e7f53f4647'
+  DEPLOY_NAME = 'graph.grf'
 
   class << self
     def remove_old_processes(project)

data/spec/helpers/project_helper.rb

@@ -15,4 +15,33 @@ module ProjectHelper
   def self.get_default_project(opts = { :client => GoodData.connection })
     GoodData::Project[PROJECT_ID, opts]
   end
+
+  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
+      next if project.pid == 'we1vvh4il93r0927r809i3agif50d7iz'
+      begin
+        puts "Deleting project #{project.title}"
+        project.delete
+      rescue e
+        puts 'ERROR: ' + e.to_s
+      end
+    end
+  end
+
+  def self.create_random_user(client)
+    num = rand(1e6)
+    login = "gemtest#{num}@gooddata.com"
+
+    GoodData::Membership.create({
+      email: login,
+      login: login,
+      first_name: 'the',
+      last_name: num.to_s,
+      role: 'editor',
+      password: CryptoHelper.generate_password,
+      domain: ConnectionHelper::DEFAULT_DOMAIN
+    }, client: client)
+  end
 end

data/spec/helpers/schedule_helper.rb

@@ -5,7 +5,7 @@ require 'pmap'
 require_relative 'process_helper'
 
 module ScheduleHelper
-  SCHEDULE_ID = '53e029bde4b035034ad4abb6'
+  SCHEDULE_ID = '54b90771e4b067429a27a549'
 
   class << self
     def remove_old_schedules(project)

data/spec/integration/command_datawarehouse_spec.rb

@@ -0,0 +1,32 @@
+require 'gooddata/commands/datawarehouse'
+
+describe GoodData::Command::DataWarehouse do
+  before(:each) do
+    @client = ConnectionHelper.create_default_connection
+  end
+
+  after(:each) do
+    @client.disconnect
+  end
+
+  it "Is Possible to create GoodData::Command::DataWarehouse instance" do
+    cmd = GoodData::Command::DataWarehouse.new()
+    cmd.should be_a(GoodData::Command::DataWarehouse)
+  end
+
+  it "Can create a data warehouse" do
+    title = 'my warehouse'
+    summary = 'hahahaha'
+    dwh = nil
+
+    begin
+      dwh = GoodData::Command::DataWarehouse.create(title: title, summary: summary, token: ConnectionHelper::GD_PROJECT_TOKEN, client: @client)
+      expect(dwh.title).to eq(title)
+      expect(dwh.summary).to eq(summary)
+      expect(dwh.id).not_to be_nil
+      expect(dwh.status).to eq('ENABLED')
+    ensure
+      dwh.delete if dwh
+    end
+  end
+end

data/spec/integration/create_project_spec.rb

@@ -15,5 +15,4 @@ describe 'Create project using GoodData client', :constraint => 'slow' do
     expect(project.title).to eq(project_title)
     project.delete
   end
-
 end

data/spec/integration/full_process_schedule_spec.rb

@@ -26,6 +26,7 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
     @process = @project.deploy_process('./spec/data/ruby_process',
                                   type: 'RUBY',
                                   name: 'Test ETL Process')
+
   end
 
   after(:all) do
@@ -109,14 +110,14 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
       expect(result.status).to eq :ok
       log = result.log
       expect(log.index('HELLO WORLD')).not_to eq nil
-      expect(schedule.enabled?).to be_true
+      expect(schedule.enabled?).to be_truthy
       schedule.disable
       schedule.save
-      expect(schedule.enabled?).to be_false
-      expect(schedule.disabled?).to be_true
+      expect(schedule.enabled?).to be_falsey
+      expect(schedule.disabled?).to be_truthy
       schedule.enable
       schedule.save
-      expect(schedule.enabled?).to be_true
+      expect(schedule.enabled?).to be_truthy
     ensure
       schedule && schedule.delete
       process && process.delete
@@ -151,7 +152,7 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
       result = schedule.execute
       expect(result.status).to eq :ok
       log = result.log
-      expect(log.index(GoodData::VERSION)).not_to eq nil
+      expect(log.index('GoodData::VERSION - 0.6.')).not_to eq nil
       expect(process.schedules.count).to eq 1
     ensure
       schedule && schedule.delete
@@ -210,4 +211,11 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
       process && process.delete
     end
   end
+
+  it "should be able to redeploy via project" do
+    process = @project.deploy_process('./spec/data/hello_world_process/hello_world.zip',
+                                  type: 'RUBY',
+                                  name: 'Test ETL zipped file Process',
+                                  process_id: @process.obj_id)
+  end
 end

data/spec/integration/full_project_spec.rb

@@ -147,6 +147,7 @@ describe "Full project implementation", :constraint => 'slow' do
     r = @project.create_report(top: [m], title: 'xy')
     rd = r.latest_report_definition
     rd.content['chart'] = { 'styles' => { 'global' => { 'colorMapping' => 1 } } }
+
     expect(GoodData::Helpers.get_path(rd.content, %w(chart styles global))).to eq ({ 'colorMapping' => 1 })
     rd.reset_color_mapping!
     expect(GoodData::Helpers.get_path(rd.content, %w(chart styles global))).to eq ({ 'colorMapping' => [] })
@@ -237,7 +238,7 @@ describe "Full project implementation", :constraint => 'slow' do
 
   it "should try setting and getting by tags" do
     fact = @project.fact_by_title('Lines Changed')
-    expect(fact.tags.empty?).to be_true
+    expect(fact.tags.empty?).to be_truthy
 
     fact.tags = "tag1,tag2,tag3"
     fact.save

data/spec/integration/over_to_user_filters_spec.rb

@@ -0,0 +1,92 @@
+require 'gooddata'
+
+describe "Variables implementation", :constraint => 'slow' do
+  before(:all) do
+    @spec = JSON.parse(File.read("./spec/data/m_n_model/blueprint.json"), :symbolize_names => true)
+    @client = ConnectionHelper::create_default_connection
+    @project = @client.create_project_from_blueprint(@spec, :auth_token => ConnectionHelper::GD_PROJECT_TOKEN)
+    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+
+    @label = GoodData::Attribute.find_first_by_title('Perm User', client: @client, project: @project).label_by_name('email')
+
+    @blueprint = GoodData::Model::ProjectBlueprint.new(@spec)
+    commits_data = [
+      ['commit_id', 'lines_changed', 'user_id'],
+      [1, 1, 1],
+      [2, 3, 2],
+      [3, 5, 3]]
+    GoodData::Model.upload_data(commits_data, @blueprint, 'commits', :client => @client, :project => @project)
+    # blueprint.find_dataset('commits').upload(commits_data)
+
+    devs_data = [
+      ["user_id", "email"],
+      [1, "tomas@gooddata.com"],
+      [2, "petr@gooddata.com"],
+      [3, "jirka@gooddata.com"]]
+    GoodData::Model.upload_data(devs_data, @blueprint, 'users', :client => @client, :project => @project)
+
+    devs_data = [
+      ["perm_user_id", "email"],
+      [1, "tomas@gooddata.com"],
+      [2, "petr@gooddata.com"],
+      [3, "jirka@gooddata.com"]]
+    GoodData::Model.upload_data(devs_data, @blueprint, 'permission_users', :client => @client, :project => @project)
+    # blueprint.find_dataset('devs').upload(devs_data)
+
+    devs_data = [
+      ['visibility_id', 'perm_user_id', 'commit_id'],
+      [1, 1, 1],
+      # [2, 1, 2],
+      [3, 1, 3]]
+    GoodData::Model.upload_data(devs_data, @blueprint, 'visibility', :client => @client, :project => @project)
+
+    @variable = @project.create_variable(title: 'uaaa', attribute: @label.attribute).save
+
+    @attr1 = GoodData::Attribute.find_first_by_title('Visibility', client: @client, project: @project)
+    @attr2 = GoodData::Attribute.find_first_by_title('Commit', client: @client, project: @project)
+
+    @filters = [
+      {
+        login: ConnectionHelper::DEFAULT_USERNAME,
+        filters: [
+          { label: @label.uri, values: ["tomas@gooddata.com"], over: @attr1.uri, to: @attr2.uri}
+        ]
+      }
+    ]
+  end
+
+  after(:all) do
+    @project.delete if @project
+  end
+
+  after(:each) do
+    @project.data_permissions.pmap &:delete
+  end
+
+  it "should fail if you are specifying OVER TO filter and variables. Variables do not support OVER TO" do
+    expect do
+      @project.add_variable_permissions(@filters, @variable)
+    end.to raise_exception
+  end
+
+  it "should create an over to filter transparently" do    
+    metric = @project.create_metric("SELECT SUM(#\"Lines Changed\")", :title => 'x')
+    expect(metric.execute).to eq 9
+    @project.add_data_permissions(@filters)
+    expect(metric.execute).to eq 6
+
+    r = @project.compute_report(left: [metric], top: @project.attributes('attr.users.user_id'))
+    expect(r.include_column?(['tomas@gooddata.com', 1])).to eq true
+    expect(r.include_column?(['jirka@gooddata.com', 5])).to eq true
+    expect(r.include_column?(['petr@gooddata.com', 3])).to eq false
+
+    devs_data = [['visibility_id', 'perm_user_id', 'commit_id'], [1, 1, 1]]
+    GoodData::Model.upload_data(devs_data, @blueprint, 'visibility', :client => @client, :project => @project)
+
+    expect(metric.execute).to eq 1
+    r = @project.compute_report(left: [metric], top: @project.attributes('attr.users.user_id'))
+    expect(r.include_column?(['tomas@gooddata.com', 1])).to eq true
+    expect(r.include_column?(['jirka@gooddata.com', 5])).to eq false
+    expect(r.include_column?(['petr@gooddata.com', 3])).to eq false
+  end
+end

data/spec/integration/project_spec.rb

@@ -0,0 +1,233 @@
+# encoding: UTF-8
+
+require 'pmap'
+require 'gooddata'
+
+describe GoodData::Project, :constraint => 'slow' do
+  before(:all) do
+    @client = ConnectionHelper::create_default_connection
+    @project = @client.create_project(title: ProjectHelper::PROJECT_TITLE, auth_token: ConnectionHelper::GD_PROJECT_TOKEN)
+    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+  end
+
+  after(:all) do
+    @project && @project.delete
+    @client.disconnect
+  end
+
+  describe '#add_user' do
+    it 'Adding user without domain should fail if it is not in the domain' 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