gooddata 0.6.49 → 0.6.50

data/spec/integration/segments_spec.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# 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.
 
@@ -8,26 +8,31 @@ 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')
+    @client = ConnectionHelper.create_default_connection
+    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+    GoodData::Segment.all(domain: @domain).each do |segment|
+      begin
+        segment.delete
+      rescue StandardError => e
+        GoodData.logger.warn "Failed to delete segment: #{e}"
+      end
+    end
   end
 
   before(:each) do
     @uuid = SecureRandom.uuid
-    @master_project = @client.create_project(title: "Test MASTER project for #{@uuid}", auth_token: TOKEN)
+    @master_project = @client.create_project(title: "Test MASTER project for #{@uuid}", auth_token: ConnectionHelper::GD_PROJECT_TOKEN)
     @segment_name = "segment-#{@uuid}"
     @segment = @domain.create_segment(segment_id: @segment_name, master_project: @master_project)
   end
 
   after(:each) do
+    @master_project.delete if @master_project
     @segment && @segment.delete(force: true)
   end
 
   after(:all) do
-    @master_project.delete if @master_project
     @client.disconnect
   end
 
@@ -39,7 +44,7 @@ describe GoodData::Segment do
 
     it 'Returns specific segment when segment ID passed' do
       s = @domain.segments(@segment_name)
-      @segment.uri == s.uri
+      expect(@segment.uri).to eq s.uri
       expect(s).to be_an_instance_of(GoodData::Segment)
       expect(@segment).to be_an_instance_of(GoodData::Segment)
     end
@@ -50,7 +55,7 @@ describe GoodData::Segment do
       old_count = @domain.segments.count
       s = @domain.segments(@segment_name)
       s.delete
-      expect(@domain.segments.length).to eq (old_count - 1)
+      expect(@domain.segments.length).to eq(old_count - 1)
       # prevent delete attempt in the after hook
       @segment = nil
     end
@@ -58,30 +63,35 @@ describe GoodData::Segment do
 
   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
+      begin
+        different_master = @client.create_project(title: 'Test project', auth_token: ConnectionHelper::GD_PROJECT_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
+      ensure
+        different_master.delete if different_master
+      end
     end
 
     it 'cannot update a segment id' do
       @segment.segment_id = 'different_id'
-      expect {
+      expect do
         @segment.save
-      }.to raise_error RestClient::BadRequest
+      end.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)
+        client_project = @client.create_project(title: 'client_1 project', auth_token: ConnectionHelper::GD_PROJECT_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
+        client_project.delete if client_project
         segment_client && segment_client.delete
       end
     end
@@ -106,34 +116,35 @@ describe GoodData::Segment 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)
+        master_project_2 = @client.create_project(title: "Test MASTER project for #{uuid_2}", auth_token: ConnectionHelper::GD_PROJECT_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)
+        data = [{ id: client_1, segment: segment_name_2 },
+                { id: client_2, segment: @segment_name }]
+        @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)
+        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)
+        data = [{ id: client_3, segment: segment_name_2 },
+                { id: client_4, segment: @segment_name }]
+        @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)
+        projects_to_delete = @domain.segments.pmapcat { |s| s.clients.to_a }.select { |c| [client_1, client_2].include?(c.id) }.map(&:project)
+        @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
+        master_project_2.delete if master_project_2
         segment_2.delete(force: true) if segment_2
       end
     end

data/spec/integration/subscription_spec.rb

@@ -0,0 +1,63 @@
+# 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::Subscription, :constraint => 'slow' do
+  before(:all) do
+    @client = ConnectionHelper.create_default_connection
+    @channel = GoodData::ChannelConfiguration.create(client: @client)
+    subscriptions = GoodData::Subscription.all(project: ProjectHelper::PROJECT_ID, client: @client)
+    subscriptions.each(&:delete)
+  end
+
+  after(:all) do
+    @channel && @channel.delete
+    @client && @client.disconnect
+  end
+
+  it 'should be able to create a subscription' do
+    begin
+      subscription = GoodData::Subscription.create(client: @client, project: ProjectHelper::PROJECT_ID, channels: @channel, message: 'hello world', process: ProcessHelper::PROCESS_ID, project_events: GoodData::Subscription::PROCESS_SUCCESS_EVENT)
+      expect(subscription.title).to eq ConnectionHelper::DEFAULT_USERNAME
+      expect(subscription.channels).to eq [@channel.uri]
+      expect(subscription.message).to eq 'hello world'
+      expect(subscription.process).to eq ProcessHelper::PROCESS_ID
+      expect(subscription.project_events).to eq [GoodData::Subscription::PROCESS_SUCCESS_EVENT]
+    ensure
+      subscription && subscription.delete
+    end
+  end
+
+  it 'should be able to edit a subscription' do
+    begin
+      subscription = GoodData::Subscription.create(client: @client, project: ProjectHelper::PROJECT_ID, channels: @channel, process: ProcessHelper::PROCESS_ID, project_events: GoodData::Subscription::PROCESS_SUCCESS_EVENT)
+      expect(subscription.title).to eq ConnectionHelper::DEFAULT_USERNAME
+
+      subscription.title = 'My title'
+      subscription.save
+
+      expect(GoodData::Subscription[subscription.subscription_id, project: ProjectHelper::PROJECT_ID, client: @client].title).to eq 'My title'
+    ensure
+      subscription && subscription.delete
+    end
+  end
+
+  it 'should be able to list all subscriptions' do
+    begin
+      expect(GoodData::Subscription.all(project: ProjectHelper::PROJECT_ID, client: @client)).to eq []
+      subscription = GoodData::Subscription.create(client: @client, project: ProjectHelper::PROJECT_ID, channels: @channel, process: ProcessHelper::PROCESS_ID, project_events: GoodData::Subscription::PROCESS_SUCCESS_EVENT)
+      expect(GoodData::Subscription.all(project: ProjectHelper::PROJECT_ID, client: @client)).to eq [subscription]
+    ensure
+      subscription && subscription.delete
+    end
+  end
+
+  it 'should be able to delete a subscription' do
+    subscription = GoodData::Subscription.create(client: @client, project: ProjectHelper::PROJECT_ID, channels: @channel, process: ProcessHelper::PROCESS_ID, project_events: GoodData::Subscription::PROCESS_SUCCESS_EVENT)
+    subscription.delete
+  end
+end

data/spec/integration/user_filters_spec.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# 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.
 
@@ -9,7 +9,7 @@ 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
+    @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)
@@ -17,25 +17,28 @@ describe "User filters implementation", :constraint => 'slow' do
     @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]]
+      %w(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"],
+      %w(dev_id email),
       [1, "tomas@gooddata.com"],
       [2, "petr@gooddata.com"],
-      [3, "jirka@gooddata.com"]]
+      [3, "jirka@gooddata.com"]
+    ]
     @project.upload(devs_data, blueprint, 'dataset.devs')
 
     repos_data = [
-      ["repo_id", "repo_name"],
+      %w(repo_id repo_name),
       [1, "goodot"],
       [2, "bam"],
-      [3, "infra"]]
+      [3, "infra"]
+    ]
     @project.upload(repos_data, blueprint, 'dataset.repos')
   end
 
@@ -44,7 +47,7 @@ describe "User filters implementation", :constraint => 'slow' do
   end
 
   after(:each) do
-    @project.data_permissions.pmap &:delete
+    @project.data_permissions.pmap(&:delete)
   end
 
   it "should create a mandatory user filter" do
@@ -54,13 +57,18 @@ describe "User filters implementation", :constraint => 'slow' do
     # [jirka@gooddata.com | petr@gooddata.com | tomas@gooddata.com]
     # [5.0                | 3.0               | 1.0               ]
 
-    metric.execute.should == 15
+    expect(metric.execute).to eq(15)
     @project.add_data_permissions(filters)
-    metric.execute.should == 12
+    expect(metric.execute).to eq(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
+    expect(r.include_column?(['tomas@gooddata.com', 7])).to be_truthy
+    expect(r.include_column?(['jirka@gooddata.com', 5])).to be_truthy
+    expect(r.include_column?(['petr@gooddata.com', 3])).to be_falsy
+
+    # should not re-create the same MUF for the same user
+    result = @project.add_data_permissions(filters, dry_run: true)
+    expect(result[:created].count).to eq 0
+    expect(result[:deleted].count).to eq 0
   end
 
   it "should return errors when asked to set a user not in project. Some filters are set up though." do
@@ -94,7 +102,8 @@ describe "User filters implementation", :constraint => 'slow' do
 
   it "should fail when asked to set a value not in the project" do
     filters = [
-      [ConnectionHelper::DEFAULT_USERNAME, @label.uri, '%^&*( nonexistent value', 'tomas@gooddata.com']]
+      [ConnectionHelper::DEFAULT_USERNAME, @label.uri, '%^&*( nonexistent value', 'tomas@gooddata.com']
+    ]
     expect do
       @project.add_data_permissions(filters)
     end.to raise_error
@@ -108,7 +117,7 @@ describe "User filters implementation", :constraint => 'slow' do
 
   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 }
+    u = domain.users.find { |user| user.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']
@@ -128,16 +137,16 @@ describe "User filters implementation", :constraint => 'slow' 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.pmap(&: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 }
+    u = domain.users.find { |user| user.login != ConnectionHelper::DEFAULT_USERNAME }
 
     filters = [[u.login, @label.uri, "tomas@gooddata.com"]]
-    results = @project.add_data_permissions(filters)
+    @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
@@ -148,7 +157,7 @@ describe "User filters implementation", :constraint => 'slow' 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]}
+    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
@@ -161,7 +170,7 @@ describe "User filters implementation", :constraint => 'slow' do
       [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] })
+    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
@@ -172,7 +181,7 @@ describe "User filters implementation", :constraint => 'slow' do
       [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] })
+    expect(@project.data_permissions.map { |f| [f.related.login, f.pretty_expression] })
       .to eq [[another_user.login, "[Dev] IN ([tomas@gooddata.com])"]]
   end
 
@@ -194,7 +203,7 @@ describe "User filters implementation", :constraint => 'slow' do
       [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] })
+    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
@@ -205,11 +214,11 @@ describe "User filters implementation", :constraint => 'slow' do
       [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] })
+    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
+  it "should be able to update the filter value", broken: true do
     pending 'FIXME: We cannot swap filters yet'
 
     filters = [[ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com", "jirka@gooddata.com"]]
@@ -226,7 +235,7 @@ describe "User filters implementation", :constraint => 'slow' do
       ['nonexistent_user@gooddata.com', @label.uri, "tomas@gooddata.com"],
       [ConnectionHelper::DEFAULT_USERNAME, @label.uri, "tomas@gooddata.com"]
     ]
-    results = @project.add_data_permissions(filters)
+    @project.add_data_permissions(filters)
 
     # now let's do a correct run
     filters = [
@@ -234,17 +243,16 @@ describe "User filters implementation", :constraint => 'slow' do
     ]
     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(results[:results].select { |r| r[:type] == :create }.count).to eq 0
     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 }
+    u = @domain.users.find { |user| user.login != ConnectionHelper::DEFAULT_USERNAME }
     password = 'abcd1234'
     u.json['accountSetting']['password'] = password
     @domain.update_user(u)
@@ -260,10 +268,11 @@ describe "User filters implementation", :constraint => 'slow' do
     # 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 [
+    @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])"]]
+      [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]
@@ -271,18 +280,19 @@ describe "User filters implementation", :constraint => 'slow' do
     # 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)
+    @project.add_data_permissions(filters)
 
-    expect(@project.data_permissions.pmap {|f| [f.related.login, f.pretty_expression]}).to eq [
+    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])"]]
+      [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)
+    @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]