gooddata 1.1.0 → 1.2.0

data/spec/integration/models/project_role_spec.rb

@@ -1,94 +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/models/project'
-require 'gooddata/models/project_role'
-
-describe GoodData::ProjectRole do
-  before(:all) do
-    @client = ConnectionHelper.create_default_connection
-    @project, * = ProjectHelper.load_full_project_implementation(@client)
-    @roles = @project.roles
-    @role = @roles.first
-  end
-
-  after(:all) do
-    @client.disconnect
-  end
-
-  describe '#author' do
-    it 'Returns author as GoodData::Profile' do
-      res = @role.author
-      expect(res).to be_an_instance_of(GoodData::Profile)
-    end
-  end
-
-  describe '#contributor' do
-    it 'Returns contributor as GoodData::Profile' do
-      res = @role.contributor
-      expect(res).to be_an_instance_of(GoodData::Profile)
-    end
-  end
-
-  describe '#created' do
-    it 'Returns created date as Time' do
-      res = @role.created
-      expect(res).to be_an_instance_of(Time)
-    end
-  end
-
-  describe '#identifier' do
-    it 'Returns identifier as String' do
-      res = @role.identifier
-      expect(res).to be_an_instance_of(String)
-    end
-  end
-
-  describe '#permissions' do
-    it 'Returns summary as Hash' do
-      res = @role.permissions
-      expect(res).to be_an_instance_of(Hash)
-    end
-  end
-
-  describe '#summary' do
-    it 'Returns summary as String' do
-      res = @role.summary
-      expect(res).to be_an_instance_of(String)
-    end
-  end
-
-  describe '#title' do
-    it 'Returns title as String' do
-      res = @role.title
-      expect(res).to be_an_instance_of(String)
-    end
-  end
-
-  describe '#updated' do
-    it 'Returns updated date as Time' do
-      res = @role.updated
-      expect(res).to be_an_instance_of(Time)
-    end
-  end
-
-  describe '#uri' do
-    it 'Returns URI as String' do
-      res = @role.uri
-      expect(res).to be_an_instance_of(String)
-    end
-  end
-
-  describe '#users' do
-    it 'Returns users as Array<GoodData::Profile>' do
-      res = @role.users
-      expect(res).to be_an_instance_of(Array)
-      res.each do |user|
-        expect(user).to be_an_instance_of(GoodData::Profile)
-      end
-    end
-  end
-end

data/spec/integration/models/project_spec.rb

@@ -1,225 +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, :constraint => 'slow' do
-  before(:all) do
-    @client = ConnectionHelper.create_default_connection
-    @project = ProjectHelper.get_default_project(:client => @client)
-    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
-  end
-
-  after(:all) do
-    @client.disconnect
-  end
-
-  describe 'projects' do
-    it 'Can get all projects' do
-      projects = @client.projects
-      expect(projects).to_not be_nil
-      expect(projects).to be_a_kind_of(Array)
-      projects.pmap do |project|
-        expect(project).to be_an_instance_of(GoodData::Project)
-      end
-    end
-
-    it 'Returns project if ID passed' do
-      expect(@project).to_not be_nil
-      expect(@project).to be_a_kind_of(GoodData::Project)
-      expect(@project.pid).to eq @project.pid
-    end
-
-    it 'Returns project if URL passed' do
-      expect(@project).to_not be_nil
-      expect(@project).to be_a_kind_of(GoodData::Project)
-      expect(@project.pid).to eq @project.pid
-    end
-
-    it 'Throws an exception when invalid format of URL passed' do
-      invalid_url = '/gdc/invalid_url'
-      expect { GoodData::Project[invalid_url] }.to raise_error
-    end
-  end
-
-  describe '#all' do
-    it 'Returns all projects' do
-      projects = GoodData::Project.all(:client => @client)
-      expect(projects).to_not be_nil
-      expect(projects).to be_a_kind_of(Array)
-    end
-  end
-
-  describe '#get_role_by_identifier' do
-    it 'Looks up for role by identifier' do
-      role = @project.get_role_by_identifier('readOnlyUserRole')
-      expect(role).to_not be_nil
-      expect(role).to be_a_kind_of(GoodData::ProjectRole)
-    end
-  end
-
-  describe '#get_role_by_summary' do
-    it 'Looks up for role by summary' do
-      role = @project.get_role_by_summary('read only user role')
-      expect(role).to_not be_nil
-      expect(role).to be_a_kind_of(GoodData::ProjectRole)
-    end
-  end
-
-  describe '#get_role_by_title' do
-    it 'Looks up for role by title' do
-      role = @project.get_role_by_title('Viewer')
-      expect(role).to_not be_nil
-      expect(role).to be_a_kind_of(GoodData::ProjectRole)
-    end
-  end
-
-  describe "#member" do
-    it 'Returns GoodData::Membership when looking for existing user using login' do
-      res = @project.get_user(ConnectionHelper::DEFAULT_USERNAME)
-      expect(res).to be_instance_of(GoodData::Membership)
-    end
-
-    it 'Returns GoodData::Membership when looking for existing user using URL' do
-      res = @project.get_user(ConnectionHelper::DEFAULT_USER_URL)
-      expect(res).to be_instance_of(GoodData::Membership)
-    end
-
-    it 'Returns GoodData::Membership when looking for existing user using GoodData::Profile' do
-      user = @project.members.first
-      res = @project.get_user(user)
-      expect(res).to be_instance_of(GoodData::Membership)
-    end
-
-    it 'Returns null for non-existing user' do
-      res = @project.get_user(ConnectionHelper::TEST_USERNAME)
-      expect(res).to be_nil
-    end
-  end
-
-  describe "#member?" do
-    it 'Returns true when looking for existing user using login' do
-      res = @project.member?(ConnectionHelper::DEFAULT_USERNAME)
-      expect(res).to be_truthy
-    end
-
-    it 'Returns true when looking for existing user using URL' do
-      res = @project.member?(ConnectionHelper::DEFAULT_USER_URL)
-      expect(res).to be_truthy
-    end
-
-    it 'Returns true when looking for existing user using GoodData::Profile' do
-      user = @project.members.first
-      res = @project.member?(user)
-      expect(res).to be_truthy
-    end
-
-    it 'Returns false for non-existing user' do
-      res = @project.member?(ConnectionHelper::TEST_USERNAME)
-      expect(res).to be_falsey
-    end
-
-    it 'Returns true for existing user when using optional list' do
-      list = @project.members
-      res = @project.member?(ConnectionHelper::DEFAULT_USERNAME, list)
-      expect(res).to be_truthy
-    end
-
-    it 'Returns false for non-existing user when using optional list' do
-      list = []
-      res = @project.member?(ConnectionHelper::DEFAULT_USERNAME, list)
-      expect(res).to be_falsey
-    end
-  end
-
-  describe '#members?' do
-    it 'Returns array of bools when looking for existing users using GoodData::Profile' do
-      users = @project.members.take(10)
-      res = @project.members?(users)
-      expect(res.all?).to be_truthy
-    end
-
-    it 'Support variety of inputs' do
-      users = @project.members.take(1)
-      res = @project.members?(users + [ConnectionHelper::TEST_USERNAME])
-      expect(res).to eq [true, false]
-    end
-  end
-
-  describe '#roles' do
-    it 'Returns array of GoodData::ProjectRole' do
-      roles = @project.roles
-      expect(roles).to be_instance_of(Array)
-
-      roles.each do |role|
-        expect(role).to be_instance_of(GoodData::ProjectRole)
-      end
-    end
-  end
-
-  describe '#export_clone' do
-    context 'when exclude_schedule is true' do
-      let(:options) { { exclude_schedules: true } }
-      let(:clone) { GoodData::Project.create(title: 'project clone', client: @client, auth_token: ConnectionHelper::GD_PROJECT_TOKEN) }
-
-      after do
-        clone.delete if clone
-      end
-
-      it 'excludes scheduled emails' do
-        @project.schedule_mail.save
-        export_token = @project.export_clone(options)
-        clone.import_clone(export_token)
-        expect(@project.scheduled_mails.to_a).not_to be_empty
-        expect(clone.scheduled_mails.to_a).to be_empty
-      end
-    end
-
-    context 'when cross_data_center_export is true' do
-      it 'is ok' do
-        # there are no staging environments on other datacenters
-        # so just checking if the parameter gets accepted
-        @project.export_clone(cross_data_center_export: true)
-      end
-    end
-
-    context 'when export task fails' do
-      let(:fail_response) do
-        response = { taskState: { status: 'ERROR' } }
-        GoodData::Helpers.stringify_keys(response)
-      end
-
-      before do
-        allow(@client)
-          .to receive(:poll_on_response).and_return(fail_response)
-      end
-
-      it 'raises ExportCloneError' do
-        expect { @project.export_clone }.to raise_error(GoodData::ExportCloneError)
-      end
-    end
-  end
-
-  describe '#import_clone' do
-    let(:clone) { GoodData::Project.create(title: 'import clone test', client: @client, auth_token: ConnectionHelper::GD_PROJECT_TOKEN) }
-    let(:fail_response) do
-      response = { taskState: { status: 'ERROR' } }
-      GoodData::Helpers.stringify_keys(response)
-    end
-
-    after do
-      clone.delete if clone
-    end
-
-    context 'when import task fails' do
-      it 'raises ImportCloneError' do
-        export_token = @project.export_clone
-        allow(@client).to receive(:poll_on_response).and_return(fail_response)
-        expect { clone.import_clone(export_token) }.to raise_error(GoodData::ImportCloneError)
-      end
-    end
-  end
-end

data/spec/integration/models/schedule_spec.rb

@@ -1,477 +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/models/schedule'
-
-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
-    @project_executable = 'graph/graph.grf'
-    @test_cron = '0 15 27 7 *'
-    @test_data = {
-      :timezone => 'UTC',
-      :cron => '2 2 2 2 *',
-      :client => @client,
-      :project => @project,
-      :params => {
-        'a' => 'b',
-        'b' => 'c'
-      }
-    }
-
-    @test_data_with_optional_param = {
-      :timezone => 'UTC',
-      :cron => '2 2 2 2 *',
-      :reschedule => 15,
-      :client => @client,
-      :project => @project
-    }
-  end
-
-  describe '#create' do
-    it 'Creates new schedule if mandatory params passed' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      expect(schedule).to be_truthy
-    end
-
-    it 'Creates new schedule if mandatory params passed and optional params are present' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-      expect(schedule).to be_truthy
-    end
-
-    it 'Throws exception when no process ID specified' do
-      expect do
-        GoodData::Schedule.create(nil, @test_cron, @project_executable, @test_data)
-      end.to raise_error 'Process ID has to be provided'
-    end
-
-    it 'Throws exception when no executable specified' do
-      expect do
-        GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, nil, @test_data)
-      end.to raise_error 'Executable has to be provided'
-    end
-  end
-
-  describe '#cron' do
-    it 'Should return cron as string' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      res = schedule.cron
-      expect(res).not_to be_nil
-      expect(res).not_to be_empty
-      expect(res).to be_a_kind_of(String)
-      expect(schedule.time_based?).to be_truthy
-    end
-  end
-
-  describe '#cron=' do
-    it 'Assigns the cron and marks the object dirty' do
-      test_cron = '2 2 2 2 *'
-
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      schedule.cron = test_cron
-      expect(schedule.cron).to eq(test_cron)
-      expect(schedule.dirty).to eq(true)
-      expect(schedule.to_hash[:cron]).to eq test_cron
-      expect(schedule.to_update_payload['schedule']['cron']).to eq test_cron
-    end
-  end
-
-  describe '#executable' do
-    it 'Should return executable as string' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      res = schedule.executable
-      expect(res).not_to be_nil
-      expect(res).not_to be_empty
-      expect(res).to be_a_kind_of(String)
-    end
-  end
-
-  describe '#executable=' do
-    it 'Assigns the executable and marks the object dirty' do
-      test_executable = 'this/is/test.grf'
-
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      schedule.executable = test_executable
-      expect(schedule.executable).to eq(test_executable)
-      expect(schedule.dirty).to eq(true)
-      expect(schedule.to_hash[:executable]).to eq test_executable
-      expect(schedule.to_update_payload['schedule']['params']['EXECUTABLE']).to eq test_executable
-    end
-  end
-
-  describe '#execute' do
-    it 'Cannot be executed if not saved' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      expect(schedule.execute).to be_nil
-    end
-  end
-
-  describe '#execution_url' do
-    it 'Should return execution URL as string' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      expect(schedule.execution_url).to be_nil
-    end
-  end
-
-  describe '#type' do
-    it 'Should return execution type as string' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      expect(schedule.type).to eq 'MSETL'
-      expect(schedule.to_hash[:type]).to eq 'MSETL'
-      expect(schedule.to_update_payload['schedule']['type']).to eq 'MSETL'
-    end
-  end
-
-  describe '#type=' do
-    it 'Assigns the type the object dirty' do
-      test_type = 'TEST'
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      schedule.type = test_type
-      expect(schedule.type).to eq(test_type)
-      expect(schedule.dirty).to eq(true)
-      expect(schedule.to_hash[:type]).to eq test_type
-      expect(schedule.to_update_payload['schedule']['type']).to eq test_type
-    end
-  end
-
-  describe '#hidden_params' do
-    it 'Should return hidden_params as hash. Empty by default.' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      res = schedule.hidden_params
-      expect(res).not_to be_nil
-      expect(res).to be_a_kind_of(Hash)
-    end
-
-    it 'Should return hidden_params as hash. Filled by default if provided.' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data.merge(hidden_params: { 'a' => 'b' }))
-      res = schedule.hidden_params
-      expect(res).not_to be_nil
-      expect(res).to be_a_kind_of(Hash)
-      expect(res['a']).to eq 'b'
-    end
-  end
-
-  describe '#hidden_params=' do
-    it 'Assigns the hidden params and marks the object dirty' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      old_params = schedule.hidden_params
-
-      test_params = {
-        'PROCESS_ID' => '1-2-3-4'
-      }
-
-      schedule.hidden_params = test_params
-      expect(schedule.hidden_params).to eq(old_params.merge(test_params))
-      expect(schedule.dirty).to eq(true)
-      expect(schedule.to_hash[:hidden_params]).to eq(test_params)
-      expect(schedule.to_update_payload['schedule']['hiddenParams']).to eq(test_params)
-    end
-  end
-
-  describe '#set_hidden_parameter' do
-    it 'Assigns the hidden parameter and marks the object dirty' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      old_params = schedule.hidden_params
-
-      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)
-      expect(schedule.to_hash[:hidden_params]).to eq(test_parameter)
-      expect(schedule.to_update_payload['schedule']['hiddenParams']).to eq(test_parameter)
-    end
-  end
-
-  describe '#set_parameter' do
-    it 'Assigns the parameter and marks the object dirty' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      old_params = schedule.params
-
-      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)
-      expect(schedule.to_hash[:params]).to eq(old_params.merge(test_parameter))
-      expect(schedule.to_update_payload['schedule']['params']).to eq(old_params.merge(test_parameter))
-    end
-  end
-
-  describe '#params' do
-    it 'Should return execution params as hash' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      res = schedule.params
-      expect(res).not_to be_nil
-      expect(res).to be_a_kind_of(Hash)
-    end
-  end
-
-  describe '#params=' do
-    it 'Updates the params and marks the object dirty' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-
-      test_params = {
-        'some_new_param' => '1-2-3-4'
-      }
-
-      schedule.params = test_params
-      expect(schedule.params.keys).to eq(%w(PROCESS_ID EXECUTABLE some_new_param))
-      expect(schedule.params['some_new_param']).to eq '1-2-3-4'
-      expect(schedule.dirty).to eq(true)
-    end
-  end
-
-  describe '#update_params' do
-    it 'Updates the params and marks the object dirty' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data.merge(params: { 'a' => 'b' }))
-
-      test_params = {
-        'some_new_param' => '1-2-3-4',
-        'a' => 'c'
-      }
-
-      schedule.update_params(test_params)
-      expect(schedule.params.keys).to eq(%w(PROCESS_ID EXECUTABLE a some_new_param))
-      expect(schedule.params['some_new_param']).to eq '1-2-3-4'
-      expect(schedule.params['a']).to eq 'c'
-      expect(schedule.dirty).to eq(true)
-    end
-  end
-
-  describe '#update_hidden_params' do
-    it 'Updates the hidden params and marks the object dirty' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data.merge(params: { 'a' => 'b' }))
-
-      schedule.update_hidden_params('some_new_param' => '1-2-3-4', 'a' => 'c', 'x' => '')
-      expect(schedule.hidden_params.keys.to_set).to eq(%w(x a some_new_param).to_set)
-      expect(schedule.hidden_params['some_new_param']).to eq '1-2-3-4'
-      expect(schedule.hidden_params['a']).to eq 'c'
-      expect(schedule.dirty).to eq(true)
-
-      schedule.update_hidden_params('some_new_param' => '1-2-3-4', 'a' => 'd')
-      expect(schedule.hidden_params.keys.to_set).to eq(%w(x a some_new_param).to_set)
-      expect(schedule.hidden_params['some_new_param']).to eq '1-2-3-4'
-      expect(schedule.hidden_params['a']).to eq 'd'
-      expect(schedule.hidden_params['x']).to eq ''
-      expect(schedule.dirty).to eq(true)
-    end
-  end
-
-  describe '#process_id' do
-    it 'Should return process id as string' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      res = schedule.process_id
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(String)
-    end
-  end
-
-  describe '#process_id=' do
-    it 'Assigns the process_id and marks the object dirty' do
-      test_process_id = '1-2-3-4'
-
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      schedule.process_id = test_process_id
-      expect(schedule.process_id).to eq(test_process_id)
-      expect(schedule.dirty).to eq(true)
-      expect(schedule.to_hash[:process_id]).to eq test_process_id
-      expect(schedule.to_update_payload['schedule']['params']['PROCESS_ID']).to eq test_process_id
-    end
-  end
-
-  describe '#state' do
-    it 'Should return schedule state as string' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      res = schedule.state
-      expect(res).not_to be_nil
-      expect(res).to eq 'ENABLED'
-      expect(schedule.to_hash[:state]).to eq 'ENABLED'
-      expect(schedule.to_update_payload['schedule']['state']).to eq 'ENABLED'
-    end
-
-    it 'Should return schedule state as string as provided' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data.merge(:state => 'DISABLED'))
-      res = schedule.state
-      expect(res).not_to be_nil
-      expect(res).to eq 'DISABLED'
-      expect(schedule.to_hash[:state]).to eq 'DISABLED'
-      expect(schedule.to_update_payload['schedule']['state']).to eq 'DISABLED'
-    end
-  end
-
-  describe '#timezone' do
-    it 'Should return timezone as string' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      res = schedule.timezone
-      expect(res).not_to be_nil
-      expect(res).to be_a_kind_of(String)
-    end
-  end
-
-  describe '#timezone=' do
-    it 'Assigns the timezone and marks the object dirty' do
-      test_timezone = 'PST'
-
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      schedule.timezone = test_timezone
-      expect(schedule.timezone).to eq(test_timezone)
-      expect(schedule.dirty).to eq(true)
-    end
-  end
-
-  describe '#reschedule' do
-    it 'Should return reschedule nil if not provided' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      expect(schedule.reschedule).to eq nil
-    end
-
-    it 'Should return reschedule as integer' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-      expect(schedule.reschedule).to eq @test_data_with_optional_param[:reschedule]
-      expect(schedule.reschedule).to be_a_kind_of(Integer)
-    end
-  end
-
-  describe '#reschedule=' do
-    it 'Assigns the reschedule and marks the object dirty' do
-      test_reschedule = 45
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-      expect(schedule.reschedule).to eq @test_data_with_optional_param[:reschedule]
-      schedule.reschedule = test_reschedule
-      expect(schedule.reschedule).to eq(test_reschedule)
-      expect(schedule.dirty).to eq(true)
-      expect(schedule.to_hash[:reschedule]).to eq test_reschedule
-      expect(schedule.to_update_payload['schedule']['reschedule']).to eq test_reschedule
-    end
-  end
-
-  describe '#name' do
-    it 'Name is nil if not specified and not saved.' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-      expect(schedule.name).to eq nil
-      expect(schedule.saved?).to eq false
-      schedule.name = 'MY NAME'
-      expect(schedule.name).to eq 'MY NAME'
-    end
-
-    it 'should be able to return your name if specified during creation.' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param.merge(name: 'My schedule name'))
-      expect(schedule.name).to eq 'My schedule name'
-    end
-  end
-
-  describe '#trigger_id=' do
-    it 'should be able to set trigger_id of the schedule.' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-      expect(schedule.dirty).to be_truthy
-      schedule.trigger_id = 'some_other_id'
-      expect(schedule.dirty).to be_truthy
-      expect(schedule.trigger_id).to eq 'some_other_id'
-    end
-  end
-
-  describe '#name=' do
-    it 'should be able to set name of the schedule.' do
-      schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-      schedule.name = 'MY NAME'
-      expect(schedule.name).to eq 'MY NAME'
-    end
-  end
-
-  describe '#after' do
-    context 'when after is not set' do
-      it 'returns nil' do
-        schedule = GoodData::Schedule.create(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-        expect(schedule.after).to be_nil
-      end
-    end
-
-    context 'when after is set' do
-      before do
-        @after_process = @project.deploy_process(
-          './spec/data/hello_world_process/hello_world.rb',
-          type: 'RUBY',
-          name: 'After Process'
-        )
-        @after_schedule = @after_process.create_schedule(
-          @test_cron,
-          @after_process.executables.first
-        )
-        @process = @project.deploy_process(
-          './spec/data/hello_world_process/hello_world.rb',
-          type: 'RUBY',
-          name: 'Main Process'
-        )
-        @schedule = @process.create_schedule(
-          @after_schedule,
-          @process.executables.first
-        )
-      end
-
-      after do
-        [@schedule, @process, @after_schedule, @after_process].each do |e|
-          e && e.delete
-        end
-      end
-
-      it 'returns the after schedule' do
-        expect(@schedule.after).to eq @after_schedule
-      end
-
-      it 'returns an updated after schedule' do
-        new_schedule = @process.create_schedule(
-          '0 0 1 1 *',
-          @process.executables.first
-        )
-        @schedule.after = new_schedule
-        expect(@schedule.after).not_to eq @after_schedule
-        expect(@schedule.after).to eq new_schedule
-      end
-    end
-  end
-
-  describe '#save' do
-    let(:model) do
-      {
-        schedule: {
-          params: { GRAPH: 'graph.grf' },
-          cron: 'foo',
-          timezone: 'bar',
-          type: 'baz',
-          links: { self: 'qux' }
-        }
-      }
-    end
-    let(:client) { double('client') }
-
-    subject { GoodData::Schedule.new(model) }
-
-    before do
-      allow(subject).to receive(:client)
-        .and_return(client)
-    end
-
-    it 'rewrites deprecated parameter GRAPH' do
-      expect(client).to receive(:put) do |_, body|
-        executable = body['schedule']['params']['EXECUTABLE']
-        expect(executable).to eq('graph.grf')
-        model
-      end
-      subject.save
-    end
-  end
-end