gooddata 1.1.0-java → 1.2.0-java

data/spec/integration/models/unit_project_spec.rb

@@ -1,130 +0,0 @@
-# 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

@@ -1,98 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,381 +0,0 @@
-# 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