gooddata 0.6.12 → 0.6.13

data/lib/gooddata/rest/client.rb

@@ -330,17 +330,13 @@ module GoodData
       end
 
       def download_from_user_webdav(source_relative_path, target_file_path, options = { :client => GoodData.client, :project => project })
-        download(source_relative_path, target_file_path, options.merge(
-            :directory => options[:directory],
-            :staging_url => get_user_webdav_url(options)
-        ))
+        download(source_relative_path, target_file_path, options.merge(:directory => options[:directory],
+                                                                       :staging_url => get_user_webdav_url(options)))
       end
 
       def upload_to_user_webdav(file, options = {})
-        upload(file, options.merge(
-          :directory => options[:directory],
-          :staging_url => get_user_webdav_url(options)
-        ))
+        upload(file, options.merge(:directory => options[:directory],
+                                   :staging_url => get_user_webdav_url(options)))
       end
 
       def with_project(pid, &block)

data/lib/gooddata/rest/connection.rb

@@ -20,7 +20,8 @@ module GoodData
       }
 
       DEFAULT_LOGIN_PAYLOAD = {
-        :headers => DEFAULT_HEADERS
+        :headers => DEFAULT_HEADERS,
+        :verify_ssl => OpenSSL::SSL::VERIFY_NONE
       }
 
       RETRYABLE_ERRORS = [
@@ -58,9 +59,10 @@ module GoodData
           retry_time = 1
           begin
             return yield
-          rescue RestClient::Forbidden => e # , RestClient::Unauthorized => e
+          rescue RestClient::Unauthorized, RestClient::Forbidden => e # , RestClient::Unauthorized => e
             raise e unless options[:refresh_token]
-            options[:refresh_token].call
+            raise e if options[:dont_reauth]
+            options[:refresh_token].call # (dont_reauth: true)
             retry if (retries -= 1) > 0
           rescue RestClient::TooManyRequests
             GoodData.logger.warn "Too many requests, retrying in #{retry_time} seconds"
@@ -122,7 +124,7 @@ module GoodData
           refresh_token :dont_reauth => true
         else
           credentials = Connection.construct_login_payload(username, password)
-          @auth = post(LOGIN_PATH, credentials, :dont_reauth => true)['userLogin']
+          @auth = post(LOGIN_PATH, credentials)['userLogin']
 
           refresh_token :dont_reauth => true
           @user = get(@auth['profile'])
@@ -401,7 +403,7 @@ module GoodData
         #   end
         # end
 
-        response = GoodData::Rest::Connection.retryable(:tries => 2, :refresh_token => proc { refresh_token }) do
+        response = GoodData::Rest::Connection.retryable(:tries => 2, :refresh_token => proc { refresh_token unless options[:dont_reauth] }) do
           block.call
         end
 

data/lib/gooddata/version.rb

@@ -2,7 +2,7 @@
 
 # GoodData Module
 module GoodData
-  VERSION = '0.6.12'
+  VERSION = '0.6.13'
 
   class << self
     # Version

data/spec/helpers/project_helper.rb

@@ -31,7 +31,7 @@ module ProjectHelper
   end
 
   def self.create_random_user(client)
-    num = rand(1e6)
+    num = rand(1e7)
     login = "gemtest#{num}@gooddata.com"
 
     GoodData::Membership.create({

data/spec/integration/full_process_schedule_spec.rb

@@ -24,14 +24,22 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
     @client = ConnectionHelper::create_default_connection
     @project = @client.create_project(title: 'Project for schedule testing', auth_token: ConnectionHelper::GD_PROJECT_TOKEN)
     @process = @project.deploy_process('./spec/data/ruby_process',
-                                  type: 'RUBY',
-                                  name: 'Test ETL Process')
+                                       type: 'RUBY',
+                                       name: 'Test ETL Process (Ruby)')
+
+    @process_cc = @project.deploy_process('./spec/data/cc',
+                                          type: 'graph',
+                                          name: 'Test ETL Process (CC)')
 
   end
 
   after(:all) do
-    @process.delete if @process
-    @project.delete if @project
+    ScheduleHelper.remove_old_schedules(@project)
+    ProcessHelper.remove_old_processes(@project)
+
+    # @process.delete if @process
+    # @project.delete if @project
+
     @client.disconnect
   end
 
@@ -58,52 +66,68 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
   end
 
   it "should be able to create schedule triggered by another schedule" do
-    schedule_first = @process.create_schedule('0 15 27 7 *', @process.executables.first)
-    schedule = @process.create_schedule(schedule_first, @process.executables.first)
-    res = @process.schedules
-    expect(res.count).to eq 2
-    expect(@process.schedules.map(&:uri)).to include(schedule_first.uri, schedule.uri)
-    schedule.delete
-    schedule_first.delete
+    begin
+      schedule_first = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+      schedule = @process.create_schedule(schedule_first, @process.executables.first)
+      res = @process.schedules
+      expect(res.count).to eq 2
+      expect(@process.schedules.map(&:uri)).to include(schedule_first.uri, schedule.uri)
+    ensure
+      schedule && schedule.delete
+      schedule_first && schedule_first.delete
+    end
   end
 
   it "should be able to create schedule triggered by another schedule specified by ID" do
-    schedule_first = @process.create_schedule('0 15 27 7 *', @process.executables.first)
-    schedule = @process.create_schedule(schedule_first.obj_id, @process.executables.first)
-    res = @process.schedules
-    expect(res.count).to eq 2
-    expect(@process.schedules.map(&:uri)).to include(schedule_first.uri, schedule.uri)
-    schedule.delete
-    schedule_first.delete
+    begin
+      schedule_first = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+      schedule = @process.create_schedule(schedule_first.obj_id, @process.executables.first)
+      res = @process.schedules
+      expect(res.count).to eq 2
+      expect(@process.schedules.map(&:uri)).to include(schedule_first.uri, schedule.uri)
+    ensure
+      schedule && schedule.delete
+      schedule_first && schedule_first.delete
+    end
   end
 
   it "should be able to delete schedule" do
-    schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
-    res = @process.schedules
-    expect(res.count).to eq 1
-    expect(@process.schedules).to eq [schedule]
-    schedule.delete
+    begin
+      schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+      res = @process.schedules
+      expect(res.count).to eq 1
+      expect(@process.schedules).to eq [schedule]
+    ensure
+      schedule && schedule.delete
+    end
   end
 
   it "should be possible to read status of schedule" do
-    schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
-    expect(schedule.state).to eq 'ENABLED'
-    schedule.delete
+    begin
+      schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+      expect(schedule.state).to eq 'ENABLED'
+    ensure
+      schedule && schedule.delete
+    end
   end
 
   it "should be possible to execute schedule" do
-    schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
-    result = schedule.execute
-    expect(result.status).to eq :ok
-    log = result.log
-    expect(log.index('Hello Ruby executors')).not_to eq nil
-    expect(log.index('Hello Ruby from the deep')).not_to eq nil
+    begin
+      schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+      result = schedule.execute
+      expect(result.status).to eq :ok
+      log = result.log
+      expect(log.index('Hello Ruby executors')).not_to eq nil
+      expect(log.index('Hello Ruby from the deep')).not_to eq nil
+    ensure
+      schedule && schedule.delete
+    end
   end
 
   it "should be possible to deploy only a single file" do
     process = @project.deploy_process('./spec/data/hello_world_process/hello_world.rb',
-                                  type: 'RUBY',
-                                  name: 'Test ETL one file Process')
+                                      type: 'RUBY',
+                                      name: 'Test ETL one file Process')
     begin
       schedule = process.create_schedule('0 15 27 7 *', process.executables.first)
       result = schedule.execute
@@ -126,8 +150,8 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
 
   it "should be possible to deploy already zipped file" do
     process = @project.deploy_process('./spec/data/hello_world_process/hello_world.zip',
-                                  type: 'RUBY',
-                                  name: 'Test ETL zipped file Process')
+                                      type: 'RUBY',
+                                      name: 'Test ETL zipped file Process')
     begin
       expect(process.schedules.count).to eq 0
       schedule = process.create_schedule('0 15 27 7 *', process.executables.first)
@@ -199,8 +223,8 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
   it "should be possible to download deployed process" do
     size = File.size('./spec/data/hello_world_process/hello_world.zip')
     process = @project.deploy_process('./spec/data/hello_world_process/hello_world.zip',
-                                  type: 'RUBY',
-                                  name: 'Test ETL zipped file Process')
+                                      type: 'RUBY',
+                                      name: 'Test ETL zipped file Process')
     begin
       Tempfile.open('downloaded-process') do |temp|
         temp << process.download
@@ -213,9 +237,26 @@ describe "Full process and schedule exercise", :constraint => 'slow' do
   end
 
   it "should be able to redeploy via project" do
-    process = @project.deploy_process('./spec/data/hello_world_process/hello_world.zip',
-                                  type: 'RUBY',
-                                  name: 'Test ETL zipped file Process',
-                                  process_id: @process.obj_id)
+    begin
+      process = @project.deploy_process('./spec/data/hello_world_process/hello_world.zip',
+                                        type: 'RUBY',
+                                        name: 'Test ETL zipped file Process',
+                                        process_id: @process.obj_id)
+    ensure
+      process && process.delete
+    end
+  end
+
+  it "should be able to redeploy directly" do
+    begin
+      process1 = @project.deploy_process('./spec/data/hello_world_process/hello_world.zip',
+                                        type: 'RUBY',
+                                        name: 'Test ETL zipped file Process')
+
+      process2 = process1.deploy('./spec/data/ruby_process/process.rb')
+      expect(process1.executables).not_to eq process2.executables
+    ensure
+      process1 && process1.delete
+    end
   end
 end

data/spec/integration/full_project_spec.rb

@@ -27,6 +27,11 @@ describe "Full project implementation", :constraint => 'slow' do
     end
   end
 
+  it "should contain metadata datasets" do
+    expect(@project.datasets.count).to eq 4
+    expect(@project.datasets.select(&:date_dimension?).count).to eq 1
+  end
+
   it "should be able to rename a project" do
     former_title = @project.title
     a_title = (0...8).map { (65 + rand(26)).chr }.join
@@ -413,4 +418,11 @@ describe "Full project implementation", :constraint => 'slow' do
     r.delete
     expect { def_uris.each {|uri| @client.get(uri)} }.to raise_error(RestClient::ResourceNotFound)
   end
+
+  it 'should be apossible to delete data from a dataset' do
+    dataset = @project.datasets('dataset.devs')
+    expect(dataset.attributes.first.create_metric.execute).to be > 0
+    dataset.delete_data
+    expect(dataset.attributes.first.create_metric.execute).to be_nil
+  end
 end

data/spec/logging_in_logging_out_spec.rb

@@ -24,4 +24,12 @@ describe GoodData::Rest::Connection, :constraint => 'slow' do
 
     regular_client.disconnect
   end
+
+  it "should be able to regenerate TT" do
+    regular_client = ConnectionHelper::create_default_connection
+    projects = regular_client.projects
+    regular_client.connection.cookies[:cookies].delete('GDCAuthTT')
+    regular_client.get('/gdc/md')
+    expect(regular_client.connection.cookies[:cookies]).to have_key 'GDCAuthTT'
+  end
 end

data/spec/spec_helper.rb

@@ -28,6 +28,8 @@ RSpec.configure do |config|
 
   config.filter_run_excluding :broken => true
 
+  config.fail_fast = true
+
   config.before(:all) do
     # TODO: Move this to some method.
     # TODO Make more intelligent so two test suites can run at the same time.

data/spec/unit/models/domain_spec.rb

@@ -82,11 +82,12 @@ describe GoodData::Domain do
 
   describe '#create_users' do
     it 'Creates new users from list' do
-      list = (0...10).to_a.map { |i| ProjectHelper.create_random_user(@client) }
+      list = (0..1).to_a.map { |i| ProjectHelper.create_random_user(@client) }
       res = @domain.create_users(list)
 
       # no errors
       expect(res.select { |x| x[:type] == :user_added_to_domain }.count).to eq res.count
+
       expect(@domain.members?(list.map(&:login)).all?).to be_truthy
 
       res.map { |r| r[:user] }.each do |r|

data/spec/unit/models/params_spec.rb

@@ -28,9 +28,12 @@ describe 'GoodData::Schedule::Params' do
         :test => '1234'
       }
 
-      res = @process.create_schedule("0 12 * * *", @graph_path, params: params)
-      expect(res).to be_truthy
-      res.delete
+      begin
+        schedule = @process.create_schedule("0 12 * * *", @graph_path, params: params)
+        expect(schedule).to be_truthy
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Works with nested params' do
@@ -41,9 +44,12 @@ describe 'GoodData::Schedule::Params' do
         }
       }
 
-      res = @process.create_schedule("0 12 * * *", @graph_path, params: params)
-      expect(res).to be_truthy
-      res.delete
+      begin
+        schedule = @process.create_schedule("0 12 * * *", @graph_path, params: params)
+        expect(schedule).to be_truthy
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Works with array in params' do
@@ -52,9 +58,12 @@ describe 'GoodData::Schedule::Params' do
         :array => [1, 2, 3, 4, 5]
       }
 
-      res = @process.create_schedule("0 12 * * *", @graph_path, params: params)
-      expect(res).to be_truthy
-      res.delete
+      begin
+        schedule = @process.create_schedule("0 12 * * *", @graph_path, params: params)
+        expect(schedule).to be_truthy
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
@@ -64,9 +73,12 @@ describe 'GoodData::Schedule::Params' do
         :test => '1234'
       }
 
-      res = @process.create_schedule("0 12 * * *", @graph_path, hiddenParams: params)
-      expect(res).to be_truthy
-      res.delete
+      begin
+        schedule = @process.create_schedule("0 12 * * *", @graph_path, hiddenParams: params)
+        expect(schedule).to be_truthy
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Works with nested hiddenParams' do
@@ -77,9 +89,12 @@ describe 'GoodData::Schedule::Params' do
         }
       }
 
-      res = @process.create_schedule("0 12 * * *", @graph_path, hiddenParams: params)
-      expect(res).to be_truthy
-      res.delete
+      begin
+        schedule = @process.create_schedule("0 12 * * *", @graph_path, hiddenParams: params)
+        expect(schedule).to be_truthy
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Works with array in hiddenParams' do
@@ -88,9 +103,12 @@ describe 'GoodData::Schedule::Params' do
         :array => [1, 2, 3, 4, 5]
       }
 
-      res = @process.create_schedule("0 12 * * *", @graph_path, hiddenParams: params)
-      expect(res).to be_truthy
-      res.delete
+      begin
+        schedule = @process.create_schedule("0 12 * * *", @graph_path, hiddenParams: params)
+        expect(schedule).to be_truthy
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 end

data/spec/unit/models/project_role_spec.rb

@@ -79,12 +79,13 @@ describe GoodData::ProjectRole do
   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
+    it 'Returns users as Array<GoodData::Profile>'
+    # 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/unit/models/schedule_spec.rb

@@ -17,7 +17,7 @@ describe GoodData::Schedule do
 
   before(:each) do
     @client = ConnectionHelper.create_default_connection
-  
+
     @project = ProjectHelper.get_default_project(:client => @client)
     @project_executable = 'graph/graph.grf'
     @test_data = {
@@ -26,7 +26,7 @@ describe GoodData::Schedule do
       :client => @client,
       :project => @project
     }
-  
+
     @test_data_with_optional_param = {
       :timezone => 'UTC',
       :cron => '2 2 2 2 *',
@@ -76,437 +76,414 @@ describe GoodData::Schedule do
 
   describe '#create' do
     it 'Creates new schedule if mandatory params passed' do
-      sched = nil
-      expect {
-        sched = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      }.not_to raise_error
-
-      sched.should_not be_nil
-      sched.delete
+      schedule = nil
+      begin
+        expect {
+          schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        }.not_to raise_error
+
+        expect(schedule).to be_truthy
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Creates new schedule if mandatory params passed and optional params are present' do
-      sched = nil
-      expect {
-        sched = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-      }.not_to raise_error
-    
-      sched.should_not be_nil
-      sched.delete
+      schedule = nil
+      begin
+        expect {
+          schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
+        }.not_to raise_error
+
+        expect(schedule).to be_truthy
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Throws exception when no process ID specified' do
-      expect {
-        sched = @project.create_schedule(nil, @test_cron, @project_executable, @test_data)
-      }.to raise_error 'Process ID has to be provided'
+      schedule = nil
+      begin
+        expect {
+          schedule = @project.create_schedule(nil, @test_cron, @project_executable, @test_data)
+        }.to raise_error 'Process ID has to be provided'
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Throws exception when no executable specified' do
-      expect {
-        sched = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, nil, @test_data)
-      }.to raise_error 'Executable has to be provided'
+      schedule = nil
+      begin
+        expect {
+          schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, nil, @test_data)
+        }.to raise_error 'Executable has to be provided'
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Throws exception when no cron is specified' do
       data = @test_data.deep_dup
       data[:cron] = nil
-      expect {
-        sched = @project.create_schedule(ProcessHelper::PROCESS_ID, nil, @project_executable, data)
-      }.to raise_error 'trigger schedule has to be provided'
+      schedule = nil
+      begin
+        expect {
+          schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, nil, @project_executable, data)
+        }.to raise_error 'trigger schedule has to be provided'
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Throws exception when no timezone specified' do
       data = @test_data.deep_dup
       data[:timezone] = nil
-      expect {
-        sched = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, data)
-      }.to raise_error 'A timezone has to be provided'
+      schedule = nil
+      begin
+        expect {
+          schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, data)
+        }.to raise_error 'A timezone has to be provided'
+      ensure
+        schedule && schedule.delete
+      end
     end
 
     it 'Throws exception when no timezone specified' do
       data = @test_data.deep_dup
       data[:type] = nil
+      schedule = nil
+      begin
       expect {
-        sched = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, data)
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, data)
       }.to raise_error 'Schedule type has to be provided'
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#cron' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return cron as string' do
-      res = @schedule.cron
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(String)
+      schedule = nil
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.cron
+        res.should_not be_nil
+        res.should_not be_empty
+        res.should be_a_kind_of(String)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#cron=' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Assigns the cron and marks the object dirty' do
       test_cron = '2 2 2 2 *'
 
-      @schedule.cron = test_cron
-      expect(@schedule.cron).to eq(test_cron)
-      expect(@schedule.dirty).to eq(true)
+      begin
+        schedule = @project.create_schedule(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)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#executable' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-    
-    after(:each) do
-      @schedule.delete
-    end
-    
     it 'Should return executable as string' do
-      res = @schedule.executable
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(String)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.executable
+        res.should_not be_nil
+        res.should_not be_empty
+        res.should be_a_kind_of(String)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#executable=' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Assigns the executable and marks the object dirty' do
-      test_executable = 'this/is/test.gr'
-
-      @schedule.executable = test_executable
-      expect(@schedule.executable).to eq(test_executable)
-      expect(@schedule.dirty).to eq(true)
+      test_executable = 'this/is/test.grf'
+
+      begin
+        schedule = @project.create_schedule(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)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#execute' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-      @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)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Waits for execution result by default' do
-      res = @schedule.execute
-      expect(res).to be_an_instance_of(GoodData::Execution)
-      expect([:ok, :error].include?(res.status)).to be_truthy
+      begin
+        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)
+        expect([:ok, :error].include?(res.status)).to be_truthy
+      ensure
+        schedule && schedule.delete
+        process && process.delete
+      end
     end
 
     it 'can be overridden to do not wait for execution result' do
-      res = @schedule.execute(:wait => false)
-      expect(res).to be_an_instance_of(GoodData::Execution)
-      expect([:scheduled, :running].include?(res.status)).to be_truthy
+      begin
+        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(:wait => false)
+        expect(res).to be_an_instance_of(GoodData::Execution)
+        expect([:scheduled, :running].include?(res.status)).to be_truthy
+      ensure
+        schedule && schedule.delete
+        process && process.delete
+      end
     end
   end
 
   describe '#execution_url' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return execution URL as string' do
-      res = @schedule.execution_url
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(String)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.execution_url
+        res.should_not be_nil
+        res.should_not be_empty
+        res.should be_a_kind_of(String)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#type' do
-
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return execution type as string' do
-      res = @schedule.type
-      res.should_not be_nil
-      res.should be_a_kind_of(String)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.type
+        res.should_not be_nil
+        res.should be_a_kind_of(String)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#hidden_params' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return execution hidden_params as hash' do
-      res = @schedule.hidden_params
-      res.should_not be_nil
-      res.should be_a_kind_of(Hash)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.hidden_params
+        res.should_not be_nil
+        res.should be_a_kind_of(Hash)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#hidden_params=' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Assigns the hidden params and marks the object dirty' do
-      @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)
+      begin
+        schedule = @project.create_schedule(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)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#params' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return execution params as hash' do
-      res = @schedule.params
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(Hash)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.params
+        res.should_not be_nil
+        res.should_not be_empty
+        res.should be_a_kind_of(Hash)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#params=' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Assigns the params and marks the object dirty' do
-      @old_params = @schedule.params
-
-      test_params = {
-        'PROCESS_ID' => '1-2-3-4'
-      }
-
-      @schedule.params = test_params
-      expect(@schedule.params).to eq(@old_params.merge(test_params))
-      expect(@schedule.dirty).to eq(true)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        old_params = schedule.params
+
+        test_params = {
+          'PROCESS_ID' => '1-2-3-4'
+        }
+
+        schedule.params = test_params
+        expect(schedule.params).to eq(old_params.merge(test_params))
+        expect(schedule.dirty).to eq(true)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#process_id' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return process id as string' do
-      res = @schedule.process_id
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(String)
+      begin
+        schedule = @project.create_schedule(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)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#process_id=' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Assigns the process_id and marks the object dirty' do
       test_process_id = '1-2-3-4'
 
-      @schedule.process_id = test_process_id
-      expect(@schedule.process_id).to eq(test_process_id)
-      expect(@schedule.dirty).to eq(true)
+      begin
+        schedule = @project.create_schedule(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)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#save' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
     it 'Should save a schedule' do
-      expect(@project.schedules(@schedule.uri)).to eq @schedule
-      expect(@client.projects(ProjectHelper::PROJECT_ID).schedules).to include(@schedule)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        expect(@project.schedules(schedule.uri)).to eq schedule
+        expect(@project.schedules).to include(schedule)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#state' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return execution state as string' do
-      res = @schedule.state
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(String)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.state
+        res.should_not be_nil
+        res.should_not be_empty
+        res.should be_a_kind_of(String)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#type' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return execution type as string' do
-      res = @schedule.type
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(String)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.type
+        res.should_not be_nil
+        res.should_not be_empty
+        res.should be_a_kind_of(String)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#type=' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Assigns the type the object dirty' do
       test_type = 'TEST'
 
-      @schedule.type = test_type
-      expect(@schedule.type).to eq(test_type)
-      expect(@schedule.dirty).to eq(true)
+      begin
+        schedule = @project.create_schedule(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)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#timezone' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Should return timezone as string' do
-      res = @schedule.timezone
-      res.should_not be_nil
-      res.should_not be_empty
-      res.should be_a_kind_of(String)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
+        res = schedule.timezone
+        res.should_not be_nil
+        res.should_not be_empty
+        res.should be_a_kind_of(String)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#timezone=' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data)
-    end
-
-    after(:each) do
-      @schedule.delete
-    end
-
     it 'Assigns the timezone and marks the object dirty' do
       test_timezone = 'PST'
 
-      @schedule.timezone = test_timezone
-      expect(@schedule.timezone).to eq(test_timezone)
-      expect(@schedule.dirty).to eq(true)
+      begin
+        schedule = @project.create_schedule(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)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#reschedule' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-    end
-  
-    after(:each) do
-      @schedule.delete
-    end
-  
     it 'Should return reschedule as integer' do
-      res = @schedule.reschedule
-      res.should_not be_nil
-      res.should be_a_kind_of(Integer)
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
+        res = schedule.reschedule
+        res.should_not be_nil
+        res.should be_a_kind_of(Integer)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 
   describe '#reschedule=' do
-    before(:each) do
-      @schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
-    end
-  
-    after(:each) do
-      @schedule.delete
-    end
-  
     it 'Assigns the reschedule and marks the object dirty' do
       test_reschedule = 45
-  
-      @schedule.reschedule = test_reschedule
-      expect(@schedule.reschedule).to eq(test_reschedule)
-      expect(@schedule.dirty).to eq(true)
+
+      begin
+        schedule = @project.create_schedule(ProcessHelper::PROCESS_ID, @test_cron, @project_executable, @test_data_with_optional_param)
+        schedule.reschedule = test_reschedule
+        expect(schedule.reschedule).to eq(test_reschedule)
+        expect(schedule.dirty).to eq(true)
+      ensure
+        schedule && schedule.delete
+      end
     end
   end
 end