gooddata 1.0.0-java

data/spec/integration/models/unit_project_spec.rb

@@ -0,0 +1,130 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'gooddata'
+
+describe GoodData::Project do
+  before(:all) do
+    @client = ConnectionHelper.create_default_connection
+    @p = GoodData::Project.create_object(title: 'a', client: @client)
+    @domain = @client.domain('dummy_domain')
+    @roles = [
+      GoodData::ProjectRole.create_object(title: 'Test Role',
+                                          summary: 'Test role summary',
+                                          identifier: 'test_role',
+                                          uri: '/roles/1',
+                                          permissions: {
+                                            "canManageFact" => "1",
+                                            "canListInvitationsInProject" => "1"
+                                          }),
+      GoodData::ProjectRole.create_object(title: 'Test Role 2',
+                                          summary: 'Test role 2 summary',
+                                          identifier: 'test_role_2',
+                                          uri: '/roles/2',
+                                          permissions: {
+                                            "canManageFact" => "1"
+                                          })
+    ]
+    @domain_members = [
+      GoodData::Profile.create_object(login: 'john.doe+in_domain@gooddata.com', uri: '/uri/john_domain')
+    ]
+    @members = [
+      GoodData::Membership.create(login: 'john.doe@goodadta.com', uri: '/uri/john'),
+      GoodData::Membership.create(login: 'jane.doe@goodadta.com', uri: '/uri/jane')
+    ]
+  end
+
+  describe 'resolve_roles' do
+    it 'Can handle case with user login when user is in the project' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles('john.doe@goodadta.com', 'test_role', project_users: @members, roles: @roles)
+      expect(a).to eq "/gdc/account/profile/john.doe@goodadta.com"
+      expect(b).to eq ["/roles/1"]
+    end
+
+    it 'Can handle case with user uri when user is in the project' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles('/uri/john', 'test_role', project_users: @members, roles: @roles)
+      expect(a).to eq "/uri/john"
+      expect(b).to eq ["/roles/1"]
+    end
+
+    it 'can handle case with info with uri when user is in the project' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles({ uri: '/uri/john', first_name: 'John' }, 'test_role', project_users: @members, roles: @roles)
+      expect(a).to eq "/uri/john"
+      expect(b).to eq ["/roles/1"]
+    end
+
+    it 'can handle case with info with login when he is in the project' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles({ login: 'john.doe@goodadta.com', first_name: 'John' }, 'test_role', project_users: @members, roles: @roles)
+      expect(a).to eq "/gdc/account/profile/john.doe@goodadta.com"
+      expect(b).to eq ["/roles/1"]
+    end
+
+    it 'can handle case with member when he is in the project' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles(@members.first, 'test_role_2', project_users: @members, roles: @roles)
+      expect(a).to eq "/uri/john"
+      expect(b).to eq ["/roles/2"]
+    end
+
+    it 'can handle case with profile when the user is in the project' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles(@domain_members.first, 'test_role_2', project_users: @members, roles: @roles)
+      expect(a).to eq "/uri/john_domain"
+      expect(b).to eq ["/roles/2"]
+    end
+
+    it 'Can handle case with user login when user is in the domain' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles('john.doe+in_domain@gooddata.com', 'test_role', project_users: [], domain_users: @domain_members, roles: @roles, domain: @domain)
+      expect(a).to eq "/gdc/account/profile/john.doe+in_domain@gooddata.com"
+      expect(b).to eq ["/roles/1"]
+    end
+
+    it 'Can handle case with user uri when user is in the domain' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles('/uri/john_domain', 'test_role', project_users: [], domain_users: @domain_members, roles: @roles, domain: @domain)
+      expect(a).to eq "/uri/john_domain"
+      expect(b).to eq ["/roles/1"]
+    end
+
+    it 'can handle case with info with uri when user is in the domain' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles({ uri: '/uri/john_domain', first_name: 'John' }, 'test_role', project_users: [], domain_users: @domain_members, roles: @roles, domain: @domain)
+      expect(a).to eq "/uri/john_domain"
+      expect(b).to eq ["/roles/1"]
+    end
+
+    it 'can handle case with info with login when he is in the domain' do
+      # we have to provide users from project to be able to do this by login
+      login = { login: 'john.doe+in_domain@gooddata.com', first_name: 'John' }
+      a, b = @p.resolve_roles(login, 'test_role',
+                              project_users: [],
+                              domain_users: @domain_members,
+                              roles: @roles,
+                              domain: @domain)
+      expect(a).to eq "/gdc/account/profile/john.doe+in_domain@gooddata.com"
+      expect(b).to eq ["/roles/1"]
+    end
+
+    it 'can handle case with member when he is in the domain' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles(@domain_members.first, 'test_role_2', project_users: [], domain_users: @domain_members, roles: @roles, domain: @domain)
+      expect(a).to eq "/uri/john_domain"
+      expect(b).to eq ["/roles/2"]
+    end
+
+    it 'can handle case with profile when the user is in the domain' do
+      # we have to provide users from project to be able to do this by login
+      a, b = @p.resolve_roles(@domain_members.first, 'test_role_2', project_users: [], domain_users: @domain_members, roles: @roles)
+      expect(a).to eq "/uri/john_domain"
+      expect(b).to eq ["/roles/2"]
+    end
+  end
+end

data/spec/integration/over_to_user_filters_spec.rb

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'gooddata'
+
+describe "Over-To data permissions implementation", :constraint => 'slow' do
+  before(:all) do
+    @spec = JSON.parse(File.read("./spec/data/blueprints/m_n_model.json"), :symbolize_names => true)
+    @client = ConnectionHelper.create_default_connection
+    @blueprint = GoodData::Model::ProjectBlueprint.new(@spec)
+    @project = @client.create_project_from_blueprint(@blueprint, :token => ConnectionHelper::GD_PROJECT_TOKEN, environment: ProjectHelper::ENVIRONMENT)
+    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+    @label = @project.attributes('attr.permission.id').label_by_name('label.permission.id.email')
+
+    data = [
+      ['label.commits.id', 'fact.commits.lines_changed', 'dataset.users'],
+      [1, 1, 1],
+      [2, 3, 2],
+      [3, 5, 3]
+    ]
+    @project.upload(data, @blueprint, 'dataset.commits')
+
+    data = [
+      ["label.users.id", "label.users.id.email"],
+      [1, "tomas@gooddata.com"],
+      [2, "petr@gooddata.com"],
+      [3, "jirka@gooddata.com"]
+    ]
+    @project.upload(data, @blueprint, 'dataset.users')
+
+    data = [
+      ["label.permission.id", "label.permission.id.email"],
+      [1, "tomas@gooddata.com"],
+      [2, "petr@gooddata.com"],
+      [3, "jirka@gooddata.com"]
+    ]
+    @project.upload(data, @blueprint, 'dataset.permission_users')
+
+    data = [
+      ['label.visibility.id', 'dataset.permission_users', 'dataset.commits'],
+      [1, 1, 1],
+      [3, 1, 3]
+    ]
+    @project.upload(data, @blueprint, 'dataset.visibility')
+
+    @variable = @project.create_variable(title: 'uaaa', attribute: @label.attribute).save
+
+    @attr1 = @project.attributes('attr.visibility.id')
+    @attr2 = @project.attributes('attr.commits.id')
+
+    @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(#\"Fact.Commits.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: ['label.users.id.email'])
+    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
+
+    data = [['label.visibility.id', 'dataset.permission_users', 'dataset.commits'], [1, 1, 1]]
+    @project.upload(data, @blueprint, 'dataset.visibility')
+
+    expect(metric.execute).to eq 1
+    r = @project.compute_report(left: [metric], top: ['label.users.id.email'])
+    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/partial_md_export_import_spec.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'gooddata'
+
+describe "Object export between projects", :constraint => 'slow' do
+  before(:all) do
+    @client = ConnectionHelper.create_default_connection
+
+    spec = MultiJson.load(File.read("./spec/data/blueprints/test_project_model_spec.json"), :symbolize_keys => true)
+
+    @source_project = @client.create_project_from_blueprint(spec, token: ConnectionHelper::GD_PROJECT_TOKEN, environment: ProjectHelper::ENVIRONMENT)
+    @target_project = @client.create_project_from_blueprint(spec, token: ConnectionHelper::GD_PROJECT_TOKEN, environment: ProjectHelper::ENVIRONMENT)
+  end
+
+  after(:all) do
+    @source_project.delete unless @source_project.nil?
+    @target_project.delete unless @target_project.nil?
+
+    @client.disconnect
+  end
+
+  it "should transfer a metric" do
+    f = GoodData::Fact.find_first_by_title('Lines Changed', :client => @client, :project => @source_project)
+    metric_title = "Testing metric to be exported"
+    metric = @source_project.create_metric("SELECT SUM(#\"#{f.title}\")", :title => metric_title)
+    metric.save
+
+    expect(@target_project.metrics.count).to eq 0
+
+    @source_project.partial_md_export(metric, :project => @target_project)
+
+    expect(@target_project.metrics.count).to eq 1
+    metric = GoodData::Metric.find_first_by_title(metric_title, :client => @client, :project => @target_project)
+    expect(metric).not_to be_nil
+    expect(metric.title).to eq metric_title
+  end
+end

data/spec/integration/project_spec.rb

@@ -0,0 +1,381 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+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, environment: ProjectHelper::ENVIRONMENT)
+    @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)
+      login = GoodData::Helpers.last_uri_part(res['projectUsersUpdateResult']['successful'].first)
+      expect(@project.member?(login)).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
+        {
+          user: ProjectHelper.create_random_user(@client),
+          role: 'Admin'
+        }
+      end
+
+      res = @project.add_users(users)
+      expect(res.select { |r| r[:type] == :failed }.count).to eq users.length
+    end
+
+    it 'Adding users with domain should pass and users should be added to domain' do
+      users = (1..5).to_a.map do
+        {
+          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.select { |r| r[:type] == :successful }.map { |i| GoodData::Helpers.last_uri_part(i[:user]) }
+      expect(@project.members?(links).all?).to be_truthy
+    end
+  end
+
+  describe '#import_users' do
+    it 'should add user which login contains a part of whitelists' do
+      users = [ProjectHelper.create_random_user(@client, login: "#{rand(1e7)}+rubydev+admin@gooddata.com")]
+      @domain.create_users(users)
+      @project.import_users(users, domain: @domain, whitelists: ['rubydev+admin@gooddata.com'])
+      expect(@domain.members?(users)).to be_truthy
+      expect(@project.members?(users)).to be_truthy
+      expect(@project.members.count).to eq 2
+    end
+
+    it "Updates user's name and surname and removes the users" do
+      users = (1..2).to_a.map { ProjectHelper.create_random_user(@client) }
+      @domain.create_users(users)
+      @project.import_users(users, domain: @domain, whitelists: [/admin@gooddata.com/])
+      expect(@domain.members?(users)).to be_truthy
+      expect(@project.members?(users)).to be_truthy
+      expect(@project.members.count).to eq 4
+      # update some user stuff
+      bill = users[0]
+      bill.first_name = 'buffalo'
+      bill.last_name = 'bill'
+      # import
+      @domain.create_users(users, domain: @domain, whitelists: [/admin@gooddata.com/])
+      @project.import_users(users, domain: @domain, whitelists: [/admin@gooddata.com/])
+      # it should be updated
+      bill_changed = @domain.get_user(bill)
+      expect(bill_changed.first_name).to eq 'buffalo'
+      expect(bill_changed.last_name).to eq 'bill'
+      expect(@project.members?(users)).to be_truthy
+      expect(@project.members.count).to eq 4
+      expect(@project.member?(bill_changed)).to be_truthy
+
+      # remove everybody but buffalo bill.
+      @project.import_users([bill], domain: @domain, whitelists: [/admin@gooddata.com/])
+      expect(@project.members.count).to eq 3
+      expect(@project.member?(bill)).to be_truthy
+      disabled_users = users - [bill]
+      expect(@project.members?(disabled_users).any?).to be_falsey
+      disabled_users.each do |user|
+        expect(@project.users(disabled: true).find { |member| member.login.downcase == user.login.downcase }).not_to be_nil
+      end
+
+      # remove completely everybody but buffalo bill.
+      @project.import_users([bill], domain: @domain, whitelists: [/admin@gooddata.com/], remove_users_from_project: true)
+      expect(@project.members.count).to eq 3
+      expect(@project.member?(bill)).to be_truthy
+      expect(@project.members?(disabled_users).any?).to be_falsey
+      disabled_users.each do |user|
+        expect(@project.users(disabled: true).find { |member| member.login.downcase == user.login.downcase }).to be_nil
+      end
+
+      # 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: [/admin@gooddata.com/])
+
+      expect(@project.members.count).to eq 4
+      expect(@project.member?(bill)).to be_truthy
+      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 { ProjectHelper.create_random_user(@client).to_hash }
+      @domain.create_users(users, domain: @domain)
+      @project.import_users(users, domain: @domain, whitelists: [/admin@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: [/admin@gooddata.com/])
+      expect(@project.get_user(user_role_changed).role.identifier).to eq "#{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 { 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: [/admin@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
+
+    it 'should downcase login' do
+      users = [ProjectHelper.create_random_user(@client, login: "#{rand(1e7)}+TMA-445+RubyDev+Admin@gooddata.com")]
+      @domain.create_users(users)
+      @project.import_users(users, domain: @domain, whitelists: ['rubydev+admin@gooddata.com'])
+      expect(@project.members?(users.map(&:to_hash).map { |u| u[:login].downcase! })).to be_truthy
+    end
+  end
+
+  describe '#set_user_roles' do
+    it 'Properly updates user roles as needed' do
+      users_to_import = @domain.users.drop(rand(100)).take(5).map { |u| { user: u, role: 'admin' } }
+      @project.import_users(users_to_import, domain: @domain, whitelists: [/admin@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.select { |r| r[:type] == :successful }.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.select { |r| r[:type] == :successful }.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 'can work with groups as well. Groups have to be set up. It can only eat hashes on input in this case' do
+      users = (1..5).to_a.map { ProjectHelper.create_random_user(@client).to_hash }
+      group_names = %w(group_1 group_2)
+      groups = group_names.map { |g| @project.create_group(name: g) }
+      users_with_groups = users.map do |u|
+        u[:user_group] = groups.take(rand(2) + 1).map(&:name)
+        u
+      end
+      @domain.create_users(users_with_groups, domain: @domain)
+      @project.import_users(users_with_groups, domain: @domain, whitelists: [/admin@gooddata.com/])
+      expect(users_with_groups.flat_map { |u| u[:user_group].map { |g| [u[:login], g] } }.all? do |u, g|
+        begin
+          @project.user_groups(g).member?(@project.member(u).uri)
+        rescue
+          false
+        end
+      end).to be_truthy
+
+      users_with_group = users.map do |u|
+        u[:user_group] = ['group_1']
+        u
+      end
+      to_whitelist = @project.user_groups('group_2').members.to_a.sample
+      @project.import_users(users_with_group, domain: @domain, whitelists: [to_whitelist.login, /admin@gooddata.com/])
+      expect(@project.user_groups('group_2').members.map(&:login)).to eq [to_whitelist.login]
+      expect(users_with_group.flat_map { |u| u[:user_group].map { |g| [u[:login], g] } }.all? do |u, g|
+        begin
+          @project.user_groups(g).member?(@project.member(u).uri)
+        rescue
+          false
+        end
+      end).to be_truthy
+    end
+
+    it 'can auto create groups and work with them' do
+      new_group = 'new_group'
+      u = @project.get_user(ConnectionHelper::DEFAULT_USERNAME)
+      uh = u.to_hash
+      uh[:user_group] = [new_group]
+
+      expect(@project.user_groups(new_group)).to be_nil
+      expect do
+        @project.import_users([uh], domain: @domain, whitelists: [/admin@gooddata.com/])
+      end.to raise_exception
+
+      @project.import_users([uh], domain: @domain, whitelists: [/admin@gooddata.com/], create_non_existing_user_groups: true)
+      expect(@project.user_groups(new_group)).not_to be_nil
+      expect(@project.user_groups(new_group).member?(u.uri)).to be_truthy
+    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
+
+  describe 'color palette' do
+    it 'should return empty when project is not set color' do
+      expect(@project.current_color_palette.colors).to eq []
+    end
+
+    it 'should be able to set custom color' do
+      colors = [
+        {
+          guid: 'first',
+          fill: {
+            r: 155,
+            g: 255,
+            b: 0
+          }
+        }
+      ]
+      @project.create_custom_color_palette(colors)
+      expect(@project.current_color_palette.colors).to eq colors.map { |color| GoodData::Helpers.stringify_keys(color) }
+    end
+
+    it 'should be able to reset custom color' do
+      colors = [
+        {
+          guid: 'first',
+          fill: {
+            r: 155,
+            g: 255,
+            b: 0
+          }
+        }
+      ]
+      @project.create_custom_color_palette(colors)
+      @project.reset_color_palette
+      expect(@project.current_color_palette.colors).to eq []
+    end
+
+    it 'should not contains duplicate color' do
+      colors = [
+        {
+          guid: 'first',
+          fill: {
+            r: 155,
+            g: 255,
+            b: 0
+          }
+        },
+        {
+          guid: 'first',
+          fill: {
+            r: 155,
+            g: 255,
+            b: 0
+          }
+        }
+      ]
+      @project.create_custom_color_palette(colors)
+      expect(@project.current_color_palette.colors).to eq [{ "guid" => "first", "fill" => { "r" => 155, "g" => 255, "b" => 0 } }]
+    end
+  end
+end