gooddata-edge 0.6.27.edge

data/spec/integration/segments_spec.rb

@@ -0,0 +1,141 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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/models/segment'
+require 'securerandom'
+
+describe GoodData::Segment do
+  TOKEN = 'mustangs'
+
+  before(:all) do
+    @client = GoodData.connect('mustang@gooddata.com', 'jindrisska', server: 'https://mustangs.intgdc.com', verify_ssl: false )
+    @domain = @client.domain('mustangs')
+  end
+
+  before(:each) do
+    @uuid = SecureRandom.uuid
+    @master_project = @client.create_project(title: "Test MASTER project for #{@uuid}", auth_token: TOKEN)
+    @segment_name = "segment-#{@uuid}"
+    @segment = @domain.create_segment(segment_id: @segment_name, master_project: @master_project)
+  end
+
+  after(:each) do
+    @segment && @segment.delete(force: true)
+  end
+
+  after(:all) do
+    @master_project.delete if @master_project
+    @client.disconnect
+  end
+
+  describe '#[]' do
+    it 'Returns all segments when :all passed' do
+      res = @domain.segments
+      expect(res).to be_an_instance_of(Array)
+    end
+
+    it 'Returns specific segment when segment ID passed' do
+      s = @domain.segments(@segment_name)
+      @segment.uri == s.uri
+      expect(s).to be_an_instance_of(GoodData::Segment)
+      expect(@segment).to be_an_instance_of(GoodData::Segment)
+    end
+  end
+
+  describe '#delete' do
+    it 'Deletes particular segment' do
+      old_count = @domain.segments.count
+      s = @domain.segments(@segment_name)
+      s.delete
+      expect(@domain.segments.length).to eq (old_count - 1)
+      # prevent delete attempt in the after hook
+      @segment = nil
+    end
+  end
+
+  describe '#save' do
+    it 'can update a segment master project' do
+      different_master = @client.create_project(title: 'Test project', auth_token: TOKEN)
+      @segment.master_project = different_master
+      @segment.save
+      @segment = @domain.segments(@segment_name)
+      expect(@segment.master_project_uri).not_to eq @master_project.uri
+      expect(@segment.master_project_uri).to eq different_master.uri
+    end
+
+    it 'cannot update a segment id' do
+      @segment.segment_id = 'different_id'
+      expect {
+        @segment.save
+      }.to raise_error RestClient::BadRequest
+    end
+  end
+
+  describe '#create_client' do
+    it 'can create a new client in a segment' do
+      begin
+        client_project = @client.create_project(title: 'client_1 project', auth_token: TOKEN)
+        segment_client = @segment.create_client(id: 'tenant_1', project: client_project)
+        expect(segment_client).to be_an_instance_of(GoodData::Client)
+        expect(@segment.clients.count).to eq 1
+      ensure
+        segment_client && segment_client.delete
+      end
+    end
+  end
+
+  describe '#provision_client_projects' do
+    it 'can create a new client in a segment without project and then provision' do
+      begin
+        segment_client = @segment.create_client(id: 'tenant_1')
+        expect(segment_client).to be_an_instance_of(GoodData::Client)
+        expect(@segment.clients.count).to eq 1
+        @domain.synchronize_clients
+        @domain.provision_client_projects
+        expect(@domain.segments.flat_map { |s| s.clients.to_a }.all?(&:project?)).to be_truthy
+      ensure
+        segment_client && segment_client.delete
+      end
+    end
+  end
+
+  describe '#update_clients' do
+    it 'can create a new client in a segment without project and then provision' do
+      begin
+        uuid_2 = SecureRandom.uuid
+        master_project_2 = @client.create_project(title: "Test MASTER project for #{uuid_2}", auth_token: TOKEN)
+        segment_name_2 = "segment-#{uuid_2}"
+        segment_2 = @domain.create_segment(segment_id: segment_name_2, master_project: master_project_2)
+
+        client_1 = "client-#{SecureRandom.uuid}"
+        client_2 = "client-#{SecureRandom.uuid}"
+        data = [{id: client_1, segment: segment_name_2 },
+                {id: client_2, segment: @segment_name }]
+        res = @domain.update_clients(data)
+        expect(@domain.segments.map(&:id)).to include(@segment.id, segment_2.id)
+        expect(@domain.segments.pmapcat {|s| s.clients.to_a }.map(&:id)).to include(client_1, client_2)
+
+        client_3 = "client-#{SecureRandom.uuid}"
+        client_4 = "client-#{SecureRandom.uuid}"
+        data = [{id: client_3, segment: segment_name_2 },
+                {id: client_4, segment: @segment_name }]
+        res = @domain.update_clients(data)
+        expect(@domain.segments.pmapcat {|s| s.clients.to_a }.map(&:id)).to include(client_1, client_2, client_3, client_4)
+
+        # bring the projects
+        @domain.synchronize_clients
+        @domain.provision_client_projects
+        projects_to_delete = @domain.segments.pmapcat {|s| s.clients.to_a }.select { |c| [client_1, client_2].include?(c.id) }.map(&:project)
+        res = @domain.update_clients(data, delete_extra: true)
+        expect(@domain.segments.pmapcat {|s| s.clients.to_a }.map(&:id)).to include(client_3, client_4)
+        expect(@domain.segments.pmapcat {|s| s.clients.to_a }.map(&:id)).not_to include(client_1, client_2)
+        expect(projects_to_delete.pmap(&:reload!).map(&:state)).to eq [:deleted, :deleted]
+      ensure
+        segment_2.delete(force: true) if segment_2
+      end
+    end
+  end
+end

data/spec/integration/user_filters_spec.rb

@@ -0,0 +1,290 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 "User filters implementation", :constraint => 'slow' do
+  before(:all) do
+    @spec = JSON.parse(File.read("./spec/data/blueprints/test_project_model_spec.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 = GoodData::Attribute.find_first_by_title('Dev', client: @client, project: @project).label_by_name('email')
+
+    commits_data = [
+      ["lines_changed","committed_on","dev_id","repo_id"],
+      [1,"01/01/2014",1,1],
+      [3,"01/02/2014",2,2],
+      [5,"05/02/2014",3,1],
+      [6,"05/02/2014",1,2]]
+    @project.upload(commits_data, blueprint, 'dataset.commits')
+
+    devs_data = [
+      ["dev_id", "email"],
+      [1, "tomas@gooddata.com"],
+      [2, "petr@gooddata.com"],
+      [3, "jirka@gooddata.com"]]
+    @project.upload(devs_data, blueprint, 'dataset.devs')
+
+    repos_data = [
+      ["repo_id", "repo_name"],
+      [1, "goodot"],
+      [2, "bam"],
+      [3, "infra"]]
+    @project.upload(repos_data, blueprint, 'dataset.repos')
+  end
+
+  after(:all) do
+    @project.delete if @project
+  end
+
+  after(:each) do
+    @project.data_permissions.pmap &:delete
+  end
+
+  it "should create a mandatory user filter" do
+    filters = [[ConnectionHelper::DEFAULT_USERNAME, @label.uri, 'tomas@gooddata.com', 'jirka@gooddata.com']]
+
+    metric = @project.create_metric("SELECT SUM(#\"Lines Changed\")", :title => 'x')
+    # [jirka@gooddata.com | petr@gooddata.com | tomas@gooddata.com]
+    # [5.0                | 3.0               | 1.0               ]
+
+    metric.execute.should == 15
+    @project.add_data_permissions(filters)
+    metric.execute.should == 12
+    r = @project.compute_report(left: [metric], top: [@label.attribute])
+    r.include_column?(['tomas@gooddata.com', 7]).should == true
+    r.include_column?(['jirka@gooddata.com', 5]).should == true
+    r.include_column?(['petr@gooddata.com', 3]).should == false
+  end
+
+  it "should return errors when asked to set a user not in project. Some filters are set up though." do
+    filters = [
+      ['nonexistent_user@gooddata.com', @label.uri, "tomas@gooddata.com"],
+      [ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com"]
+    ]
+    results = @project.add_data_permissions(filters)
+    expect(results[:results].any? { |r| r[:status] == :failed }).to be_truthy
+    expect(@project.data_permissions.count).to eq 2
+  end
+
+  it "should pass and set users that are in the projects" do
+    filters = [
+      [ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com"]
+    ]
+    @project.add_data_permissions(filters)
+    expect(@project.data_permissions.count).to eq 1
+  end
+
+  it "should pass and set only users that are in the projects if asked" do
+    filters = [
+      ['nonexistent_user@gooddata.com', @label.uri, 'tomas@gooddata.com'],
+      [ConnectionHelper::DEFAULT_USERNAME, @label.uri, 'tomas@gooddata.com']
+    ]
+    # note that filters will be set up even for nonexistent users but they will not be assigned
+    @project.add_data_permissions(filters, users_must_exist: false)
+    expect(@project.data_permissions.select(&:related_uri).count).to eq 1
+    expect(@project.data_permissions.select(&:related_uri).first.pretty_expression).to eq "[Dev] IN ([tomas@gooddata.com])"
+  end
+
+  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']]
+    expect do
+      @project.add_data_permissions(filters)
+    end.to raise_error
+    begin
+      @project.add_data_permissions(filters)
+    rescue GoodData::FilterMaqlizationError => e
+      expect(e.errors.count).to eq 1
+    end
+    expect(@project.data_permissions.count).to eq 0
+  end
+
+  it 'should fail but return all values if specified' do
+    domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+    u = domain.users.find { |u| u.login != ConnectionHelper::DEFAULT_USERNAME }
+    filters = [
+      [ConnectionHelper::DEFAULT_USERNAME, @label.uri, '%^&*( nonexistent value', 'tomas@gooddata.com'],
+      [u.login, @label.uri, '%^&*( other nonexistent value', 'jirka@gooddata.com']
+    ]
+    expect do
+      @project.add_data_permissions(filters, fail_early: false)
+    end.to raise_error
+    begin
+      @project.add_data_permissions(filters, fail_early: false)
+    rescue GoodData::FilterMaqlizationError => e
+      expect(e.errors.count).to eq 2
+    end
+    expect(@project.data_permissions.count).to eq 0
+  end
+
+  it "should add a filter with nonexistent values when asked" do
+    filters = [[ConnectionHelper::DEFAULT_USERNAME, @label.uri, '%^&*( nonexistent value', 'jirka@gooddata.com']]
+    @project.add_data_permissions(filters, ignore_missing_values: true)
+
+    expect(@project.data_permissions.pmap {|m| m.pretty_expression}).to eq ["[Dev] IN ([jirka@gooddata.com])"]
+    expect(@project.data_permissions.count).to eq 1
+  end
+
+  it "should be able to add mandatory filter to a user not in the project if domain is provided" do
+    domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+    u = domain.users.find { |u| u.login != ConnectionHelper::DEFAULT_USERNAME }
+
+    filters = [[u.login, @label.uri, "tomas@gooddata.com"]]
+    results = @project.add_data_permissions(filters)
+    filters = @project.data_permissions
+    expect(filters.first.related.login).to eq u.login
+    expect(filters.select(&:related_uri).count).to eq 1
+    expect(filters.first.pretty_expression).to eq "[Dev] IN ([tomas@gooddata.com])"
+  end
+
+  it "should be able to print data permissions in a human readable form" do
+    filters = [[ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com"]]
+    @project.add_data_permissions(filters)
+    perms = @project.data_permissions
+    pretty = perms.pmap {|f| [f.related.login, f.pretty_expression]}
+    expect(perms.first.related).to eq @client.user
+    expect(pretty).to eq [[ConnectionHelper::DEFAULT_USERNAME, "[Dev] IN ([tomas@gooddata.com])"]]
+  end
+
+  it "sets up mandatory users based on the state given as an end state by default." do
+    # first let's prepare some user filters
+    user_with_already_set_up_filter = @project.get_user(ConnectionHelper::DEFAULT_USERNAME)
+
+    filters = [
+      [user_with_already_set_up_filter.login, @label.uri, "tomas@gooddata.com"]
+    ]
+    @project.add_data_permissions(filters)
+    expect(@project.data_permissions.map {|f| [f.related.login, f.pretty_expression] })
+      .to eq [[ConnectionHelper::DEFAULT_USERNAME, "[Dev] IN ([tomas@gooddata.com])"]]
+
+    # Now let's add user filter to a different user. If we do not explicitely state that
+    # user_with_already_set_up_filter should keep his filter it will be removed
+    another_user = @domain.users.find { |u| u.login != ConnectionHelper::DEFAULT_USERNAME }
+    @project.add_user(another_user, 'Admin', domain: @domain)
+    new_filters = [
+      [another_user.login, @label.uri, "tomas@gooddata.com"]
+    ]
+    @project.add_data_permissions(new_filters)
+    expect(@project.data_permissions.map {|f| [f.related.login, f.pretty_expression] })
+      .to eq [[another_user.login, "[Dev] IN ([tomas@gooddata.com])"]]
+  end
+
+  it "should set up false if all values are nonexistent" do
+    metric = GoodData::Fact.find_first_by_title('Lines Changed', client: @client, project: @project).create_metric
+
+    filters = [[ConnectionHelper::DEFAULT_USERNAME, @label.uri, "NONEXISTENT1", "NONEXISTENT2", "NONEXISTENT3"]]
+    @project.add_data_permissions(filters, ignore_missing_values: true)
+    expect(metric.execute).to eq 15
+    @project.add_data_permissions(filters, ignore_missing_values: true, restrict_if_missing_all_values: true)
+    expect(metric.execute).to eq nil
+  end
+
+  it "you can switch the updates. Whatever is not mentioned will not be touched" do
+    # first let's prepare some user filters
+    user_with_already_set_up_filter = @project.get_user(ConnectionHelper::DEFAULT_USERNAME)
+
+    filters = [
+      [user_with_already_set_up_filter.login, @label.uri, "tomas@gooddata.com"]
+    ]
+    @project.add_data_permissions(filters)
+    expect(@project.data_permissions.map {|f| [f.related.login, f.pretty_expression] })
+      .to eq [[ConnectionHelper::DEFAULT_USERNAME, "[Dev] IN ([tomas@gooddata.com])"]]
+
+    # Now let's add user filter to a different user. If we do not explicitely state that
+    # user_with_already_set_up_filter should keep his filter it will be removed
+    another_user = @domain.users.find { |u| u.login != ConnectionHelper::DEFAULT_USERNAME }
+    @project.add_user(another_user, 'Admin', domain: @domain)
+    new_filters = [
+      [another_user.login, @label.uri, "tomas@gooddata.com"]
+    ]
+    @project.add_data_permissions(new_filters, do_not_touch_filters_that_are_not_mentioned: true)
+    expect(@project.data_permissions.map {|f| [f.related.login, f.pretty_expression] })
+      .to include([ConnectionHelper::DEFAULT_USERNAME, "[Dev] IN ([tomas@gooddata.com])"], [another_user.login, "[Dev] IN ([tomas@gooddata.com])"])
+  end
+
+  it "should be able to update the filter value" do
+    pending 'FIXME: We cannot swap filters yet'
+
+    filters = [[ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com", "jirka@gooddata.com"]]
+    @project.add_data_permissions(filters)
+    perm = @project.data_permissions.first
+    filters = [[ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com"]]
+    @project.add_data_permissions(filters)
+    expect(perm.reload!.pretty_expression).to eq '[Dev] IN ([tomas@gooddata.com, jirka@gooddata.com])'
+  end
+
+  it 'should not create any superfluous filters if things go well' do
+    # first create some filters. This will error out and some filters will stay there
+    filters = [
+      ['nonexistent_user@gooddata.com', @label.uri, "tomas@gooddata.com"],
+      [ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com"]
+    ]
+    results = @project.add_data_permissions(filters)
+
+    # now let's do a correct run
+    filters = [
+      [ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com"]
+    ]
+    results = @project.add_data_permissions(filters)
+    expect(results[:results].all? { |r| r[:status] == :successful }).to be_truthy
+    expect(results[:results].select {|r| r[:type] == :create }.count).to eq 1
+    expect(@project.data_permissions.count).to eq 1
+  end
+
+  it "should create a mandatory user filter with double filters" do
+
+    repo_label = @project.labels('some_attr_label_id')
+    metric = @project.create_metric("SELECT SUM(#\"Lines Changed\")")
+
+    # we want to compute stuff on different user than we are setting it on
+    u = @domain.users.find { |u| u.login != ConnectionHelper::DEFAULT_USERNAME }
+    password = 'abcd1234'
+    u.json['accountSetting']['password'] = password
+    @domain.update_user(u)
+    @project.add_user(u, 'admin')
+
+    computation_client = GoodData.connect(u.login, password, verify_ssl: false)
+    computation_project = computation_client.projects(@project.pid)
+
+    # verify we are set up
+    r = computation_project.compute_report(left: [metric, 'some_attr_label_id'], top: [@label])
+    expect(r.column(4)).to eq ["tomas@gooddata.com", 6, 1]
+
+    # lets restrict tomas to goodot only
+    filters = [[u.login, @label.uri, 'tomas@gooddata.com'],
+               [u.login, repo_label.uri, 'goodot']]
+    results = @project.add_data_permissions(filters)
+    expect(@project.data_permissions.pmap {|f| [f.related.login, f.pretty_expression]}).to eq [
+      [u.login, "[Dev] IN ([tomas@gooddata.com])"],
+      [u.login, "[Repository Name] IN ([goodot])"]]
+
+    r = computation_project.compute_report(left: [metric, 'some_attr_label_id'], top: [@label])
+    expect(r.column(2)).to eq ["tomas@gooddata.com", 1]
+
+    # Now lets change repo to bam
+    filters = [[u.login, @label.uri, 'tomas@gooddata.com'],
+               [u.login, repo_label.uri, 'bam']]
+    results = @project.add_data_permissions(filters)
+
+    expect(@project.data_permissions.pmap {|f| [f.related.login, f.pretty_expression]}).to eq [
+      [u.login, "[Dev] IN ([tomas@gooddata.com])"],
+      [u.login, "[Repository Name] IN ([bam])"]]
+
+    r = computation_project.compute_report(left: [metric, 'some_attr_label_id'], top: [@label])
+    expect(r.column(2)).to eq ["tomas@gooddata.com", 6]
+
+    # let's remove the repo restriction
+    filters = [[u.login, @label.uri, 'tomas@gooddata.com']]
+    results = @project.add_data_permissions(filters)
+
+    r = computation_project.compute_report(left: [metric, 'some_attr_label_id'], top: [@label])
+    expect(r.column(2)).to eq ["tomas@gooddata.com", 6, 1]
+  end
+end

data/spec/integration/user_group_spec.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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.
+
+describe GoodData::UserGroup do
+  before(:all) do
+    @bulk_size = 3
+
+    @user_group_name = 'My Test Group'
+    @user_group_description = 'My Test Description'
+
+    @client = ConnectionHelper::create_default_connection
+    @project = @client.create_project(title: 'UserGroup Testing Project', token: ConnectionHelper::GD_PROJECT_TOKEN, environment: ProjectHelper::ENVIRONMENT)
+    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+
+    users = (1..5).to_a.map do |x|
+      {
+        user: ProjectHelper.create_random_user(@client),
+        role: 'Admin'
+      }
+    end
+
+    @project.add_users(users)
+    @users = @project.users.to_a
+
+    @group = @project.add_user_group(:name => @user_group_name, :description => @user_group_description)
+  end
+
+  after(:all) do
+    @group && @group.delete
+    @project && @project.delete
+    @client.disconnect
+  end
+
+  describe '#[]' do
+    it 'Should list user groups as Array' do
+      res = GoodData::UserGroup[:all, :client => @client, :project => @project]
+      expect(res).to be_kind_of(Array)
+    end
+  end
+
+  describe '#add_members' do
+    it 'Should add member' do
+      users = @users.to_a.take(@bulk_size)
+
+      old_count = @group.members.to_a.length
+      @group.add_member(users)
+
+      new_count = @group.members.to_a.length
+      expect(new_count).to eq (old_count + 1)
+
+      group_members = @group.members.to_a
+
+      users.each do |user|
+        res = group_members.find do |group_member|
+          group_member.uri == user.uri
+        end
+        expect(res).to be_a_kind_of(GoodData::Profile)
+      end
+    end
+  end
+
+  describe '#set_members' do
+    it 'Should set new members' do
+      users = @users.to_a.take(@bulk_size)
+
+      @group.set_members(users)
+
+      group_members = @group.members.to_a
+      expect(group_members.length).to eq users.length
+    end
+  end
+
+  describe '#remove_members' do
+    it 'Should remove existing members' do
+      users = @users.to_a.take(@bulk_size)
+
+      @group.set_members(users)
+
+      group_members = @group.members.to_a
+      expect(group_members.length).to eq users.length
+
+      @group.remove_members(users)
+      group_members = @group.members.to_a
+      expect(group_members.length).to eq 0
+    end
+  end
+
+  describe '#members' do
+    it 'Should return members as array' do
+      expect(@group.members).to be_a_kind_of(Enumerator)
+
+      members = @group.members.to_a
+      expect(members).to be_kind_of(Array)
+    end
+  end
+
+  describe '#name' do
+    it 'Should return name of user group' do
+      expect(@group.name).to eq @user_group_name
+    end
+  end
+
+  describe '#name=' do
+    it 'Should assign name of user group' do
+      new_name = 'This is new name'
+      @group.name = new_name
+      expect(@group.name).to eq new_name
+    end
+  end
+
+  describe '#description' do
+    it 'Should return name of user group' do
+      expect(@group.description).to eq @user_group_description
+    end
+  end
+
+  describe '#description=' do
+    it 'Should assign description of user group' do
+      new_description = 'This is new description'
+      @group.description = new_description
+      expect(@group.description).to eq new_description
+    end
+  end
+end