gooddata 0.6.49 → 0.6.50

data/spec/integration/over_to_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 "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
+    @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)
@@ -19,27 +19,31 @@ describe "Over-To data permissions implementation", :constraint => 'slow' do
       ['label.commits.id', 'fact.commits.lines_changed', 'dataset.users'],
       [1, 1, 1],
       [2, 3, 2],
-      [3, 5, 3]]
+      [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"]]
+      [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"]]
+      [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]]
+      [3, 1, 3]
+    ]
     @project.upload(data, @blueprint, 'dataset.visibility')
 
     @variable = @project.create_variable(title: 'uaaa', attribute: @label.attribute).save
@@ -51,7 +55,7 @@ describe "Over-To data permissions implementation", :constraint => 'slow' do
       {
         login: ConnectionHelper::DEFAULT_USERNAME,
         filters: [
-          { label: @label.uri, values: ["tomas@gooddata.com"], over: @attr1.uri, to: @attr2.uri}
+          { label: @label.uri, values: ["tomas@gooddata.com"], over: @attr1.uri, to: @attr2.uri }
         ]
       }
     ]
@@ -62,7 +66,7 @@ describe "Over-To data permissions implementation", :constraint => 'slow' do
   end
 
   after(:each) do
-    @project.data_permissions.pmap &:delete
+    @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
@@ -71,7 +75,7 @@ describe "Over-To data permissions implementation", :constraint => 'slow' do
     end.to raise_exception
   end
 
-  it "should create an over to filter transparently" do    
+  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)

data/spec/integration/partial_md_export_import_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.
 
@@ -11,7 +11,7 @@ describe "Object export between projects", :constraint => 'slow' 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
@@ -29,7 +29,7 @@ describe "Object export between projects", :constraint => 'slow' do
     metric = @source_project.create_metric("SELECT SUM(#\"#{f.title}\")", :title => metric_title)
     metric.save
 
-    @target_project.metrics.count.should == 0
+    expect(@target_project.metrics.count).to eq 0
 
     @source_project.partial_md_export(metric, :project => @target_project)
 
@@ -38,5 +38,4 @@ describe "Object export between projects", :constraint => 'slow' do
     expect(metric).not_to be_nil
     expect(metric.title).to eq metric_title
   end
-
 end

data/spec/integration/project_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 GoodData::Project, :constraint => 'slow' do
   before(:all) do
-    @client = ConnectionHelper::create_default_connection
+    @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
@@ -38,7 +38,7 @@ describe GoodData::Project, :constraint => 'slow' do
 
   describe '#add_users' do
     it 'Adding user without domain should fail if it is not in the project' do
-      users = (1..5).to_a.map do |x|
+      users = (1..5).to_a.map do
         {
           user: ProjectHelper.create_random_user(@client),
           role: 'Admin'
@@ -50,47 +50,69 @@ describe GoodData::Project, :constraint => 'slow' do
     end
 
     it 'Adding users with domain should pass and users should be added to domain' do
-      users = (1..5).to_a.map do |x|
+      users = (1..5).to_a.map do
         {
           user: ProjectHelper.create_random_user(@client),
           role: 'Admin'
         }
       end
-      @domain.create_users(users.map {|u| u[:user]})
+      @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]) }
+      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 { |x| ProjectHelper.create_random_user(@client) }
+      users = (1..2).to_a.map { ProjectHelper.create_random_user(@client) }
       @domain.create_users(users)
-      result = @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+      @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 3
+      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: [/gem_tester@gooddata.com/])
-      @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+      @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 3
+      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: [/gem_tester@gooddata.com/])
-      expect(@project.members.count).to eq 2
+      @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?(users - [bill]).any?).to be_falsey
+      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'
@@ -98,25 +120,25 @@ describe GoodData::Project, :constraint => 'slow' do
       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: [/gem_tester@gooddata.com/])
+      @project.import_users(additional_batch.map { |u| { user: u, role: u.role } }, domain: @domain, whitelists: [/admin@gooddata.com/])
 
-      expect(@project.members.count).to eq 3
+      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 { |x| ProjectHelper.create_random_user(@client).to_hash }
+      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: [/gem_tester@gooddata.com/])
+      @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: [/gem_tester@gooddata.com/])
+      @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']
+      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
@@ -124,22 +146,21 @@ describe GoodData::Project, :constraint => 'slow' do
       uh = u.to_hash
       uh[:role] = 'editor'
 
-      users = (1..5).to_a.map { |x| ProjectHelper.create_random_user(@client).to_hash } + [uh]
+      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: [/gem_tester@gooddata.com/])
+      @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
-
   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: [/gem_tester@gooddata.com/])
+      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
@@ -180,51 +201,64 @@ describe GoodData::Project, :constraint => 'slow' do
       # 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
+      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
-      
+      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 { |x| ProjectHelper.create_random_user(@client).to_hash }
-      group_names = ['group_1', 'group_2']
+      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 { |u| u[:user_group] = groups.take(rand(2) + 1).map(&:name); u}
+      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: [/gem_tester@gooddata.com/])
+      @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|
-        @project.user_groups(g).member?(@project.member(u).uri) rescue false
+        begin
+          @project.user_groups(g).member?(@project.member(u).uri)
+        rescue
+          false
+        end
       end).to be_truthy
 
-      users_with_group = users.map { |u| u[:user_group] = ['group_1']; u}
+      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, /gem_tester@gooddata.com/])
+      @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|
-        @project.user_groups(g).member?(@project.member(u).uri) rescue false
+        begin
+          @project.user_groups(g).member?(@project.member(u).uri)
+        rescue
+          false
+        end
       end).to be_truthy
     end
   end
@@ -261,4 +295,29 @@ describe GoodData::Project, :constraint => 'slow' do
       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 = [{ r: 155, g: 255, b: 0 }]
+      @project.create_custom_color_palette(colors)
+      expect(@project.current_color_palette.colors).to eq colors
+    end
+
+    it 'should be able to reset custom color' do
+      colors = [{ 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 = [{ r: 155, g: 255, b: 0 }, { r: 155, g: 255, b: 0 }]
+      @project.create_custom_color_palette(colors)
+      expect(@project.current_color_palette.colors).to eq [{ r: 155, g: 255, b: 0 }]
+    end
+  end
 end

data/spec/integration/rest_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.
 
@@ -28,7 +28,6 @@ describe GoodData do
 
   def test_webdav_upload(params)
     GoodData.with_project(@project, :client => @client) do
-
       # use current timestamp as a directory name on webdav
       dir = params[:no_dir] ? nil : Time.now.to_i.to_s
       dir = "#{dir}/#{dir}" if params[:nested_dir]
@@ -72,7 +71,9 @@ describe GoodData do
 
       # if it's unknown it should raise an error, otherwise it should download the right stuff
       if params[:unknown_file]
-        expect{ download_block.call }.to raise_error(ArgumentError)
+        expect do
+          download_block.call
+        end.to raise_error(ArgumentError)
       else
         download_block.call
 
@@ -210,4 +211,4 @@ describe GoodData do
       expect(@client.user_webdav_path).to eq GoodData::Environment::ConnectionHelper::STAGING_URI
     end
   end
-end
+end

data/spec/integration/schedule_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.
 
@@ -11,13 +11,6 @@ describe GoodData::Schedule do
   SCHEDULE_ID = ScheduleHelper::SCHEDULE_ID
   SCHEDULE_URL = "/gdc/projects/#{ProjectHelper::PROJECT_ID}/schedules/#{SCHEDULE_ID}"
 
-  before(:all) do
-    @client = ConnectionHelper.create_default_connection
-    @project = ProjectHelper.get_default_project(:client => @client)
-    # ScheduleHelper.remove_old_schedules(@project)
-    # ProcessHelper.remove_old_processes(@project)
-  end
-
   before(:each) do
     @client = ConnectionHelper.create_default_connection
 
@@ -103,9 +96,9 @@ describe GoodData::Schedule do
     it 'Throws exception when no process ID specified' do
       schedule = nil
       begin
-        expect {
+        expect do
           schedule = @project.create_schedule(nil, @test_cron, ProcessHelper::DEPLOY_NAME, @test_data)
-        }.to raise_error 'Process ID has to be provided'
+        end.to raise_error 'Process ID has to be provided'
       ensure
         schedule && schedule.delete
       end
@@ -114,9 +107,9 @@ describe GoodData::Schedule do
     it 'Throws exception when no executable specified' do
       schedule = nil
       begin
-        expect {
+        expect do
           schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, nil, @test_data)
-        }.to raise_error 'Executable has to be provided'
+        end.to raise_error 'Executable has to be provided'
       ensure
         schedule && schedule.delete
       end
@@ -127,9 +120,9 @@ describe GoodData::Schedule do
       data[:cron] = nil
       schedule = nil
       begin
-        expect {
+        expect do
           schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, nil, ProcessHelper::DEPLOY_NAME, data)
-        }.to raise_error 'Trigger schedule has to be provided'
+        end.to raise_error 'Trigger schedule has to be provided'
       ensure
         schedule && schedule.delete
       end
@@ -140,9 +133,9 @@ describe GoodData::Schedule do
       schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, ProcessHelper::DEPLOY_NAME, data)
       schedule.timezone = nil
       begin
-        expect {
+        expect do
           schedule.save
-        }.to raise_error 'A timezone has to be provided'
+        end.to raise_error 'A timezone has to be provided'
       ensure
         schedule && schedule.delete
       end
@@ -154,9 +147,9 @@ describe GoodData::Schedule do
       begin
         schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, ProcessHelper::DEPLOY_NAME, data)
         schedule.type = nil
-        expect {
+        expect do
           schedule.save
-        }.to raise_error 'Schedule type has to be provided'
+        end.to raise_error 'Schedule type has to be provided'
       ensure
         schedule && schedule.delete
       end
@@ -225,9 +218,11 @@ describe GoodData::Schedule do
   describe '#execute' do
     it 'Waits for execution result by default' do
       begin
-        process = @project.deploy_process('./spec/data/gooddata_version_process/gooddata_version.zip',
-                                           type: 'RUBY',
-                                           name: 'Test ETL zipped file GoodData Process')
+        process = @project.deploy_process(
+          './spec/data/gooddata_version_process/gooddata_version.zip',
+          type: 'RUBY',
+          name: 'Test ETL zipped file GoodData Process'
+        )
         schedule = process.create_schedule('0 15 27 7 *', process.executables.first)
         res = schedule.execute
         expect(res).to be_an_instance_of(GoodData::Execution)
@@ -319,7 +314,7 @@ describe GoodData::Schedule do
         schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, ProcessHelper::DEPLOY_NAME, @test_data)
         old_params = schedule.hidden_params
 
-        test_parameter = {'test_parameter' => 'just_testing' }
+        test_parameter = { 'test_parameter' => 'just_testing' }
         schedule.set_hidden_parameter(test_parameter.keys.first, test_parameter.values.first)
         expect(schedule.hidden_params).to eq(old_params.merge(test_parameter))
         expect(schedule.dirty).to eq(true)
@@ -335,7 +330,7 @@ describe GoodData::Schedule do
         schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, ProcessHelper::DEPLOY_NAME, @test_data)
         old_params = schedule.params
 
-        test_parameter = {'test_parameter' => 'just_testing' }
+        test_parameter = { 'test_parameter' => 'just_testing' }
         schedule.set_parameter(test_parameter.keys.first, test_parameter.values.first)
         expect(schedule.params).to eq(old_params.merge(test_parameter))
         expect(schedule.dirty).to eq(true)
@@ -344,7 +339,6 @@ describe GoodData::Schedule do
       end
     end
   end
-  
 
   describe '#params' do
     it 'Should return execution params as hash' do
@@ -364,7 +358,6 @@ describe GoodData::Schedule do
     it 'Assigns the params and marks the object dirty' do
       begin
         schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, ProcessHelper::DEPLOY_NAME, @test_data)
-        old_params = schedule.params
 
         test_params = {
           'some_new_param' => '1-2-3-4'
@@ -538,7 +531,7 @@ describe GoodData::Schedule do
     it 'should be able to get name of the schedule.' do
       begin
         schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, ProcessHelper::DEPLOY_NAME, @test_data_with_optional_param)
-        expect(schedule.name).to eq ProcessHelper::DEPLOY_NAME
+        expect("cc/graph/#{schedule.name}").to eq ProcessHelper::DEPLOY_NAME
       ensure
         schedule && schedule.delete
       end
@@ -587,7 +580,7 @@ describe GoodData::Schedule do
       begin
         process = @project.processes(ProcessHelper::PROCESS_ID)
         schedule = process.create_schedule(@test_cron, ProcessHelper::DEPLOY_NAME, @test_data_with_optional_param)
-        expect(schedule.name).to eq ProcessHelper::DEPLOY_NAME
+        expect("cc/graph/#{schedule.name}").to eq ProcessHelper::DEPLOY_NAME
         schedule.name = 'MY NAME'
         schedule.save
         schedule2 = process.schedules.find { |s| s.obj_id == schedule.obj_id }
@@ -602,20 +595,16 @@ describe GoodData::Schedule do
     it 'should preserve the hidden parmeters.' do
       begin
         process = @project.processes(ProcessHelper::PROCESS_ID)
-        schedule = process.create_schedule(@test_cron, ProcessHelper::DEPLOY_NAME, @test_data_with_optional_param.merge({hidden_params: {
-          "a" => {
-            "b" => "c"
-          }
-        }}))
-        
+        schedule = process.create_schedule(
+          @test_cron,
+          ProcessHelper::DEPLOY_NAME,
+          @test_data_with_optional_param.merge(hidden_params: { "a" => { "b" => "c" } })
+        )
+
         schedule.save
-        expect(schedule.hidden_params).to eq({
-          GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY => nil
-        })
+        expect(schedule.hidden_params).to eq(GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY => nil)
         schedule2 = process.schedules.find { |s| s.uri == schedule.uri }
-        expect(schedule2.to_update_payload['schedule']['hiddenParams']).to eq ({
-          GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY => nil
-        })
+        expect(schedule2.to_update_payload['schedule']['hiddenParams']).to eq(GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY => nil)
       ensure
         schedule && schedule.delete
       end