gooddata 0.6.7 → 0.6.8

data/spec/data/users.csv

@@ -1,12 +1,12 @@
-First Name,Last Name,Email,Password,MUF,MUF ID,Role,Role ID,Project ID,Domain
-Gem,Tester,svarovsky+gem_tester@gooddata.com,jindrisska,Edit,,adminRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User0,test.user.110@example.com,password0,Full,,adminRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User1,test.user.111@example.com,password1,Full,,connectorsSystemRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User2,test.user.112@example.com,password2,Full,,editorRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User3,test.user.113@example.com,password3,Full,,dashboardOnlyRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User4,test.user.114@example.com,password4,Full,,unverifiedAdminRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User5,test.user.115@example.com,password5,Full,,readOnlyUserRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User6,test.user.116@example.com,password6,Full,,adminRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User7,test.user.117@example.com,password7,Full,,connectorsSystemRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User8,test.user.118@example.com,password8,Full,,editorRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
-Test,User9,test.user.119@example.com,password9,Full,,dashboardOnlyRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+First Name,Last Name,Email,Password,MUF,MUF ID,Role,Role ID,Project ID,Domain
+Gem,Tester,svarovsky+gem_tester@gooddata.com,jindrisska,Edit,,adminRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User0,test.user.110@example.com,password0,Full,,adminRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User1,test.user.111@example.com,password1,Full,,connectorsSystemRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User2,test.user.112@example.com,password2,Full,,editorRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User3,test.user.113@example.com,password3,Full,,dashboardOnlyRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User4,test.user.114@example.com,password4,Full,,unverifiedAdminRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User5,test.user.115@example.com,password5,Full,,readOnlyUserRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User6,test.user.116@example.com,password6,Full,,adminRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User7,test.user.117@example.com,password7,Full,,connectorsSystemRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User8,test.user.118@example.com,password8,Full,,editorRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky
+Test,User9,test.user.119@example.com,password9,Full,,dashboardOnlyRole,5,wgqhml3se0035s8n5byqdq0j0ob5jam4,gooddata-tomas-svarovsky

data/spec/helpers/connection_helper.rb

@@ -16,6 +16,12 @@ module ConnectionHelper
     GoodData::connect(username, password)
   end
 
+  def self.disconnect
+    conn = GoodData.connection.connection
+    GoodData.disconnect
+    puts conn.stats_table
+  end
+
   # Creates connection using environment varibles GD_GEM_USER and GD_GEM_PASSWORD
   def self.create_private_connection
     username = ENV['GD_GEM_USER'] || DEFAULT_USERNAME

data/spec/helpers/process_helper.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+# Global requires
+require 'multi_json'
+
+# Local requires
+require 'gooddata/models/models'
+
+module ProcessHelper
+  PROCESS_ID = 'dc143d80-58a1-4acd-96b6-8d11fc4571de'
+  DEPLOY_NAME = 'graph'
+end

data/spec/helpers/project_helper.rb

@@ -12,7 +12,7 @@ module ProjectHelper
   PROJECT_TITLE = 'GoodTravis'
   PROJECT_SUMMARY = 'No summary'
 
-  def self.get_default_project
-    GoodData::Project[PROJECT_ID]
+  def self.get_default_project(opts = { :client => GoodData.connection })
+    GoodData::Project[PROJECT_ID, opts]
   end
 end

data/spec/integration/command_projects_spec.rb

@@ -3,25 +3,27 @@ require 'gooddata/commands/project'
 
 describe GoodData::Command::Project, :constraint => 'slow' do
   before(:all) do
+    @client = ConnectionHelper.create_default_connection
+
     @blueprint = GoodData::Model::ProjectBlueprint.from_json("./spec/data/test_project_model_spec.json")
     @module_blueprint = GoodData::Model::ProjectBlueprint.from_json("./spec/data/additional_dataset_module.json")
 
-    ConnectionHelper::create_default_connection
-    @project = GoodData::Command::Project.build({:spec => @blueprint, :token => ConnectionHelper::GD_PROJECT_TOKEN})
+    @project = GoodData::Command::Project.build({:spec => @blueprint, :token => ConnectionHelper::GD_PROJECT_TOKEN, :client => @client})
   end
 
   after(:all) do
     @project.delete unless @project.nil?
+
+    @client.disconnect
   end
 
   it "should update the project" do
     @blueprint.merge!(@module_blueprint)
-    GoodData.with_project(@project) do |p|
-      p.blueprint.datasets.count.should == 3
-      p.blueprint.datasets(:include_date_dimensions => true).count.should == 4
-      GoodData::Command::Project.update({:spec => @blueprint, :project => p})
-      p.blueprint.datasets.count.should == 4
-      p.blueprint.datasets(:include_date_dimensions => true).count.should == 5
-    end
+    @project.blueprint.datasets.count.should == 3
+    @project.blueprint.datasets(:include_date_dimensions => true).count.should == 4
+    GoodData::Command::Project.update({:spec => @blueprint, :client => @client, :project => @project})
+    @project.blueprint.datasets.count.should == 4
+    @project.blueprint.datasets(:include_date_dimensions => true).count.should == 5
+
   end
 end

data/spec/integration/create_from_template_spec.rb

@@ -2,11 +2,15 @@ require 'gooddata'
 
 describe "Spin a project from template", :constraint => 'slow' do
   before(:all) do
-    ConnectionHelper::create_default_connection
+    @client = ConnectionHelper.create_default_connection
+  end
+
+  after(:all) do
+    @client.disconnect
   end
 
   it "should spin a project from a template that does not exist. It should throw an error" do
-    expect{GoodData::Project.create(:title => "Test project", :template => "/some/nonexisting/template/uri", :auth_token => ConnectionHelper::GD_PROJECT_TOKEN)}.to raise_error
+    expect{GoodData::Project.create(:title => "Test project", :template => "/some/nonexisting/template/uri", :auth_token => ConnectionHelper::GD_PROJECT_TOKEN, :client => @client)}.to raise_error
   end
 
 end

data/spec/integration/full_process_schedule_spec.rb

@@ -2,68 +2,81 @@ require 'gooddata'
 
 describe "Full process and schedule exercise", :constraint => 'slow' do
   before(:all) do
-    ConnectionHelper::create_default_connection
-    @project = GoodData::Project.create(title: 'Project for schedule testing', auth_token: ConnectionHelper::GD_PROJECT_TOKEN)
-    @process = GoodData::Process.with_deploy('./spec/data/ruby_process',
+    @client = ConnectionHelper::create_default_connection
+    @project = GoodData::Project.create(title: 'Project for schedule testing', auth_token: ConnectionHelper::GD_PROJECT_TOKEN, :client => @client)
+    @process = @project.deploy_process('./spec/data/ruby_process',
                                   type: 'RUBY',
-                                  project: @project,
                                   name: 'Test ETL Process')
   end
 
   after(:all) do
     @process.delete if @process
     @project.delete if @project
+    @client.disconnect
   end
 
   it "should be able to execute a process" do
-    pending('Account cannot execute Ruby')
-    GoodData.with_project(@project) do |project|
-      result = @process.execute(@process.executables.first)
-      log = GoodData.get(result['executionDetail']['links']['log'])
-      expect(log.index('Hello Ruby executors')).not_to eq nil
-      expect(log.index('Hello Ruby from the deep')).not_to eq nil
-    end
+    result = @process.execute(@process.executables.first)
+    log = @client.get(result['executionDetail']['links']['log'])
+    expect(log.index('Hello Ruby executors')).not_to eq nil
+    expect(log.index('Hello Ruby from the deep')).not_to eq nil
   end
 
   it "should be able to grab executables" do 
-    pending('Account cannot execute Ruby')
+
     expect(@process.executables).to eq ['./process.rb']
   end
 
   it "should have empty schedules on deploy" do 
-    pending('Account cannot execute Ruby')
-    GoodData.with_project(@project) do |project|
-      expect(@process.schedules).to eq []
-    end
+    expect(@process.schedules).to eq []
   end
 
-  it "should be able to schedule" do
-    pending('Account cannot execute Ruby')
-    GoodData.with_project(@project) do |project|
-      schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
-      expect(@process.schedules.count).to eq 1
-      expect(@process.schedules).to eq [schedule]
-      schedule.delete
-    end
+  it "should be able to delete schedule" do
+    schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+    expect(@process.schedules.count).to eq 1
+    expect(@process.schedules).to eq [schedule]
+    schedule.delete
   end
 
   it "should be possible to read status of schedule" do
-    pending('Account cannot execute Ruby')
-    GoodData.with_project(@project) do |project|
-      schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
-      expect(schedule.state).to eq 'ENABLED'
-      schedule.delete
-    end
+    schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+    expect(schedule.state).to eq 'ENABLED'
+    schedule.delete
   end
 
   it "should be possible to execute schedule" do
-    pending('Account cannot execute Ruby')
-    GoodData.with_project(@project) do |project|
-      schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+    schedule = @process.create_schedule('0 15 27 7 *', @process.executables.first)
+    result = schedule.execute
+    log = @client.get(result['execution']['log'])
+    expect(log.index('Hello Ruby executors')).not_to eq nil
+    expect(log.index('Hello Ruby from the deep')).not_to eq nil
+  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')
+    begin
+      schedule = process.create_schedule('0 15 27 7 *', process.executables.first)
+      result = schedule.execute
+      log = @client.get(result['execution']['log'])
+      expect(log.index('HELLO WORLD')).not_to eq nil
+    ensure
+      process && process.delete
+    end
+  end
+
+  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')
+    begin
+      schedule = process.create_schedule('0 15 27 7 *', process.executables.first)
       result = schedule.execute
-      log = GoodData.get(result['execution']['log'])
-      expect(log.index('Hello Ruby executors')).not_to eq nil
-      expect(log.index('Hello Ruby from the deep')).not_to eq nil
+      log = @client.get(result['execution']['log'])
+      expect(log.index('HELLO WORLD')).not_to eq nil
+    ensure
+      process && process.delete
     end
   end
 end

data/spec/integration/full_project_spec.rb

@@ -2,55 +2,57 @@ require 'gooddata'
 
 describe "Full project implementation", :constraint => 'slow' do
   before(:all) do
-    @spec = JSON.parse(File.read('./spec/data/test_project_model_spec.json'), :symbolize_names => true)
-    @invalid_spec = JSON.parse(File.read('./spec/data/blueprint_invalid.json'), :symbolize_names => true)
-    ConnectionHelper::create_default_connection
-    @project = GoodData::Model::ProjectCreator.migrate(:spec => @spec, :token => ConnectionHelper::GD_PROJECT_TOKEN)
+    @spec = JSON.parse(File.read("./spec/data/test_project_model_spec.json"), :symbolize_names => true)
+    @invalid_spec = JSON.parse(File.read("./spec/data/blueprint_invalid.json"), :symbolize_names => true)
+    @client = ConnectionHelper::create_default_connection
+    @project = GoodData::Model::ProjectCreator.migrate({:spec => @spec, :token => ConnectionHelper::GD_PROJECT_TOKEN, :client => @client})
   end
 
   after(:all) do
     @project.delete unless @project.nil?
+
+    @client.disconnect
   end
 
   it "should not build an invalid model" do
     expect {
-      GoodData::Model::ProjectCreator.migrate({:spec => @invalid_spec, :token => ConnectionHelper::GD_PROJECT_TOKEN})
+      GoodData::Model::ProjectCreator.migrate({:spec => @invalid_spec, :token => ConnectionHelper::GD_PROJECT_TOKEN, :client => @client})
     }.to raise_error(GoodData::ValidationError)
   end
 
   it "should contain datasets" do
-    GoodData.with_project(@project) do |p|
-      p.blueprint.tap do |bp|
-        expect(bp.datasets.count).to eq 3
-        expect(bp.datasets(:include_date_dimensions => true).count).to eq 4
-      end
+    @project.blueprint.tap do |bp|
+      expect(bp.datasets.count).to eq 3
+      expect(bp.datasets(:include_date_dimensions => true).count).to eq 4
     end
   end
 
   it "should be able to rename a project" do
-    GoodData.with_project(@project) do |p|
-      former_title = p.title
-      a_title = (0...8).map { (65 + rand(26)).chr }.join
-      p.title = a_title
-      p.save
-      expect(p.title).to eq a_title
-      p.title = former_title
-      p.save
-    end
+    former_title = @project.title
+    a_title = (0...8).map { (65 + rand(26)).chr }.join
+    @project.title = a_title
+    @project.save
+    expect(@project.title).to eq a_title
+    @project.title = former_title
+    @project.save
   end
 
   it "should be able to validate a project" do
-    GoodData.with_project(@project) do |p|
-      p.validate
-    end
+    @project.validate
   end
 
   it "should compute an empty metric" do
-    GoodData.with_project(@project) do |p|
-      f = GoodData::Fact.find_first_by_title('Lines Changed')
-      metric = GoodData::Metric.xcreate("SELECT SUM(#\"#{f.title}\")")
-      metric.execute.should be_nil
-    end
+    f = @project.fact_by_title('Lines Changed')
+    metric = @project.create_metric("SELECT SUM(#\"#{f.title}\")")
+    expect(metric.execute).to be_nil
+  end
+
+  it "should compute an empty report def" do
+    @project.delete_all_data(force: true)
+    f = @project.fact_by_title('Lines Changed')
+    metric = @project.create_metric("SELECT SUM(#\"#{f.title}\")")
+    res = GoodData::ReportDefinition.execute(:left => [metric], :client => @client, :project => @project);
+    expect(res).to be_empty
   end
 
   it "should load the data" do
@@ -61,7 +63,7 @@ describe "Full project implementation", :constraint => 'slow' do
         [1,"01/01/2014",1,1],
         [3,"01/02/2014",2,2],
         [5,"05/02/2014",3,1]]
-      GoodData::Model.upload_data(commits_data, blueprint, 'commits')
+      GoodData::Model.upload_data(commits_data, blueprint, 'commits', :client => @client, :project => @project)
       # blueprint.find_dataset('commits').upload(commits_data)
 
       devs_data = [
@@ -69,329 +71,292 @@ describe "Full project implementation", :constraint => 'slow' do
         [1, "tomas@gooddata.com"],
         [2, "petr@gooddata.com"],
         [3, "jirka@gooddata.com"]]
-      GoodData::Model.upload_data(devs_data, blueprint, 'devs')
+      GoodData::Model.upload_data(devs_data, blueprint, 'devs', :client => @client, :project => @project)
       # blueprint.find_dataset('devs').upload(devs_data)
     end
   end
 
   it "should compute a metric" do
-    GoodData.with_project(@project) do |p|
-      f = GoodData::Fact.find_first_by_title('Lines Changed')
-      metric = GoodData::Metric.xcreate("SELECT SUM(#\"#{f.title}\")")
-      metric.execute.should == 9
-    end
+    f = @project.fact_by_title('Lines Changed')
+    metric = @project.create_metric("SELECT SUM(#\"#{f.title}\")")
+    expect(metric.execute).to eq 9
   end
 
   it "should execute an anonymous metric twice and not fail" do
-    GoodData.with_project(@project) do |p|
-      f = GoodData::Fact.find_first_by_title('Lines Changed')
-      metric = GoodData::Metric.xcreate("SELECT SUM(#\"#{f.title}\")")
-      metric.execute.should == 9
-      # Since GD platform cannot execute inline specified metric the metric has to be saved
-      # The code tries to resolve this as transparently as possible
-      metric.execute.should == 9
-    end
+    f = @project.fact_by_title('Lines Changed')
+    metric = @project.create_metric("SELECT SUM(#\"#{f.title}\")")
+    expect(metric.execute).to eq 9
+    # Since GD platform cannot execute inline specified metric the metric has to be saved
+    # The code tries to resolve this as transparently as possible
+    # Here we are testing that you can execute the metric twice. The first execution is on unsaved metric
+    # We wanna make sure that when we are cleaning up we are not messing things up
+    expect(metric.execute).to eq 9
   end
 
-  it "should compute a report" do
-    GoodData.with_project(@project) do |p|
-      f = GoodData::Fact.find_first_by_title('Lines Changed')
-      # TODO: Here we create metric which is not deleted and is used by another test - "should exercise the object relations and getting them in various ways"
-      metric = GoodData::Metric.xcreate(:title => "My metric", :expression => "SELECT SUM(#\"#{f.title}\")")
-      metric.save
-      result = GoodData::ReportDefinition.execute(:title => "My report", :top => [metric], :left => ['label.devs.dev_id.email'])
-      result[1][1].should == 3
-      result.include_row?(["jirka@gooddata.com", 5]).should == true
-
-      result2 = GoodData::ReportDefinition.create(:title => "My report", :top => [metric], :left => ['label.devs.dev_id.email']).execute
-      result2[1][1].should == 3
-      result2.include_row?(["jirka@gooddata.com", 5]).should == true
-      result2.should == result
-    end
+  it "should compute a report def" do
+    f = @project.fact_by_title('Lines Changed')
+
+    # TODO: Here we create metric which is not deleted and is used by another test - "should exercise the object relations and getting them in various ways"
+    metric = @project.create_metric("SELECT SUM(#\"#{f.title}\")", :title => "My metric")
+    metric.save
+    result = GoodData::ReportDefinition.execute(:title => "My report", :top => [metric], :left => ['label.devs.dev_id.email'], :client => @client, :project => @project)
+    expect(result[1][1]).to eq 3
+    expect(result.include_row?(["jirka@gooddata.com", 5])).to be true
+
+    result2 = GoodData::ReportDefinition.create(:title => "My report", :top => [metric], :left => ['label.devs.dev_id.email'], :client => @client, :project => @project).execute
+    expect(result2[1][1]).to eq 3
+    expect(result2.include_row?(["jirka@gooddata.com", 5])).to eq true
+    expect(result2).to eq result
   end
 
-  it "should throw an exception if trying to access object without explicitely specifying a project" do
-    expect do
-      GoodData::Metric[:all]
-    end.to raise_exception(GoodData::NoProjectError)
+  it "should be able to purge report from older revisions" do
+    m = @project.metrics.first
+    r = @project.create_report(top: [m], title: 'xy')
+    expect(r.definitions.count).to eq 1
+
+    rd = GoodData::ReportDefinition.create(:top => [m], :client => @client, :project => @project)
+    rd.save
+    r.add_definition(rd)
+    r.save
+    expect(r.definitions.count).to eq 2
   end
 
   it "should be possible to get all metrics" do
-    GoodData.with_project(@project) do |p|
-      metrics1 = GoodData::Metric[:all]
-      metrics2 = GoodData::Metric.all
-      metrics1.should == metrics2
-    end
+    metrics1 = @project.metrics
+    expect(metrics1.count).to be >= 0
   end
 
   it "should be possible to get all metrics with full objects" do
-    GoodData.with_project(@project) do |p|
-      metrics1 = GoodData::Metric[:all, :full => true]
-      metrics2 = GoodData::Metric.all :full => true
-      metrics1.should == metrics2
-    end
+    metrics1 = @project.metrics(:all, full: false)
+    expect(metrics1.first.class).to be Hash
   end
 
   it "should be able to get a metric by identifier" do
-    GoodData.with_project(@project) do |p|
-      metrics = GoodData::Metric.all :full => true
-      metric = GoodData::Metric[metrics.first.identifier]
-      metric.identifier == metrics.first.identifier
-      metrics.first == metric
-    end
+    metrics = @project.metrics
+    metric = @project.metrics(metrics.first.identifier)
+    expect(metric.identifier).to eq metrics.first.identifier
+    expect(metrics.first).to eq metric
   end
 
   it "should be able to get a metric by uri" do
-    GoodData.with_project(@project) do |p|
-      metrics = GoodData::Metric.all :full => true
-      metric = GoodData::Metric[metrics.first.uri]
-      metric.uri == metrics.first.uri
-      metrics.first == metric
-    end
+    metrics = @project.metrics
+    metric = @project.metrics(metrics.first.uri)
+    expect(metric.uri).to eq metrics.first.uri
+    expect(metrics.first).to eq metric
   end
 
   it "should be able to get a metric by object id" do
-    GoodData.with_project(@project) do |p|
-      metrics = GoodData::Metric.all :full => true
-      metric = GoodData::Metric[metrics.first.obj_id]
-      metric.obj_id == metrics.first.obj_id
-      metrics.first == metric
-    end
+    metrics = @project.metrics
+    metric = @project.metrics(metrics.first.obj_id)
+    expect(metric.obj_id).to eq metrics.first.obj_id
+    expect(metrics.first).to eq metric
   end
 
   it "should exercise the object relations and getting them in various ways" do
-    GoodData.with_project(@project) do |p|
+    # Find a metric by name
+    metric = @project.metric_by_title('My metric')
+    the_same_metric = @project.metrics(metric)
+    expect(metric).to eq the_same_metric
 
-      # Find a metric by name
-      metric = GoodData::Metric.find_first_by_title('My metric')
-      the_same_metric = GoodData::Metric[metric]
-      metric.should == metric
+    # grab fact in several different ways
+    fact1 = @project.fact_by_title('Lines Changed')
+    fact2 = @project.facts(fact1.identifier)
+    fact3 = @project.facts(fact2.obj_id)
+    fact4 = @project.facts(fact3.uri)
+    fact5 = @client.create(GoodData::Fact, fact4)
 
-      # grab fact in several different ways
-      fact1 = GoodData::Fact.find_first_by_title('Lines Changed')
-      fact2 = GoodData::Fact[fact1.identifier]
-      fact3 = GoodData::Fact[fact2.obj_id]
-      fact4 = GoodData::Fact[fact3.uri]
-      fact5 = GoodData::Fact.new(fact4)
+    # All should be the same
+    expect(fact1).to eq fact2
+    expect(fact1).to eq fact2
+    expect(fact1).to eq fact3
+    expect(fact1).to eq fact4
+    expect(fact1).to eq fact5
 
-      # All should be the same
-      fact1.should == fact2
-      fact1.should == fact2
-      fact1.should == fact3
-      fact1.should == fact4
-      fact1.should == fact5
+    fact3.title = "Somewhat changed title"
+    expect(fact1).not_to eq fact3
 
-      fact3.title = "Somewhat changed title"
-      fact1.should_not == fact3
+    metric.using(nil)
+    expect(metric.using('fact', :client => @client, :project => @project).count).to eq 1
 
-      metric.using
-      metric.using('fact').count.should == 1
+    fact1.used_by(nil)
+    expect(fact1.used_by('metric', :client => @client, :project => @project).count).to eq 1
 
-      fact1.used_by
-      fact1.used_by('metric').count.should == 1
+    res = metric.using?(fact1)
+    expect(res).to be(true)
 
-      res = metric.using?(fact1)
-      expect(res).to be(true)
+    res = fact1.using?(metric)
+    expect(res).to be(false)
 
-      res = fact1.using?(metric)
-      expect(res).to be(false)
+    res = metric.used_by?(fact1)
+    expect(res).to be(false)
 
-      res = metric.used_by?(fact1)
-      expect(res).to be(false)
-
-      res = fact1.used_by?(metric)
-      expect(res).to be(true)
-    end
+    res = fact1.used_by?(metric)
+    expect(res).to be(true)
   end
 
   it "should try setting and getting by tags" do
-    GoodData.with_project(@project) do |p|
-      fact = GoodData::Fact.find_first_by_title('Lines Changed')
-      fact.tags.should be_empty
+    fact = @project.fact_by_title('Lines Changed')
+    expect(fact.tags.empty?).to be_true
 
-      fact.tags = "tag1,tag2,tag3"
-      fact.save
+    fact.tags = "tag1,tag2,tag3"
+    fact.save
 
-      tagged_facts = GoodData::Fact.find_by_tag('tag3')
-      tagged_facts.count.should == 1
-    end
+    tagged_facts = GoodData::Fact.find_by_tag('tag3', :client => @client, :project => @project)
+    expect(tagged_facts.count).to eq 1
   end
 
   it "should contain metadata for each dataset in project metadata" do
-    GoodData.with_project(@project) do |p|
-      k = GoodData::ProjectMetadata.keys
-      k.should include("manifest_devs")
-    end
+    k = GoodData::ProjectMetadata.keys(:client => @client, :project => @project)
+    expect(k).to include("manifest_devs")
   end
 
   it "should be able to interpolate metric based on" do
-    GoodData.with_project(@project) do |p|
-      res = GoodData::Metric.xexecute "SELECT SUM(![fact.commits.lines_changed])"
-      res.should == 9
+    res = GoodData::Metric.xexecute "SELECT SUM(![fact.commits.lines_changed])", :client => @client, :project => @project
+    expect(res).to eq 9
 
-      res = GoodData::Metric.xexecute({:expression => "SELECT SUM(![fact.commits.lines_changed])"})
-      res.should == 9
+    res = GoodData::Metric.xexecute( "SELECT SUM(![fact.commits.lines_changed])", :client => @client, :project => @project)
+    expect(res).to eq 9
 
-      res = GoodData::Metric.execute({:expression => "SELECT SUM(![fact.commits.lines_changed])", :extended_notation => true})
-      res.should == 9
+    res = GoodData::Metric.execute("SELECT SUM(![fact.commits.lines_changed])", :extended_notation => true, :client => @client, :project => @project)
+    expect(res).to eq 9
 
-      res = GoodData::Metric.execute("SELECT SUM(![fact.commits.lines_changed])", :extended_notation => true)
-      res.should == 9
+    res = GoodData::Metric.execute("SELECT SUM(![fact.commits.lines_changed])", :extended_notation => true, :client => @client, :project => @project)
+    expect(res).to eq 9
 
-      fact = GoodData::Fact.find_first_by_title('Lines Changed')
-      fact.fact?.should == true
-      res = fact.create_metric(:type => :sum).execute
-      res.should == 9
-    end
+    fact = @project.fact_by_title('Lines Changed')
+    expect(fact.fact?).to be true
+    res = fact.create_metric(:type => :sum).execute
+    expect(res).to eq 9
   end
 
   it "should load the data" do
-    GoodData.with_project(@project) do |p|
-      blueprint = GoodData::Model::ProjectBlueprint.new(@spec)
-      devs_data = [
-        ["dev_id", "email"],
-        [4, "josh@gooddata.com"]]
-      GoodData::Model.upload_data(devs_data, blueprint, 'devs', mode: 'INCREMENTAL' )
-      # blueprint.find_dataset('devs').upload(devs_data, :load => 'INCREMENTAL')
-    end
+    blueprint = GoodData::Model::ProjectBlueprint.new(@spec)
+    devs_data = [
+      ["dev_id", "email"],
+      [4, "josh@gooddata.com"]]
+    GoodData::Model.upload_data(devs_data, blueprint, 'devs', mode: 'INCREMENTAL', :client => @client, :project => @project)
+    # blueprint.find_dataset('devs').upload(devs_data, :load => 'INCREMENTAL')
   end
 
   it "should have more users"  do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      attribute.attribute?.should == true
-      attribute.create_metric.execute.should == 4
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    expect(attribute.attribute?).to be true
+    expect(attribute.create_metric.execute).to eq 4
   end
 
   it "should tell you whether metric contains a certain attribute" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      repo_attribute = GoodData::Attribute['attr.repos.repo_id']
-      metric = attribute.create_metric(:title => "My test metric")
-      metric.save
-      metric.execute.should == 4
-
-      metric.contain?(attribute).should == true
-      metric.contain?(repo_attribute).should == false
-
-      metric.replace(attribute, repo_attribute)
-      metric.save
-      metric.execute.should_not == 4
-
-      l = attribute.primary_label
-      value = l.values.first[:value]
-      l.find_element_value(l.find_value_uri(value)).should == value
-      expect(l.value?(value)).to eq true
-      expect(l.value?("DEFINITELY NON EXISTENT VALUE HOPEFULLY")).to eq false
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    repo_attribute = @project.attributes('attr.repos.repo_id')
+    metric = attribute.create_metric(:title => "My test metric")
+    metric.save
+    expect(metric.execute).to eq 4
+
+    expect(metric.contain?(attribute)).to be true
+    expect(metric.contain?(repo_attribute)).to be false
+
+    metric.replace(attribute, repo_attribute)
+    metric.save
+    expect(metric.execute).not_to eq 4
+
+    l = attribute.primary_label
+    value = l.values.first[:value]
+    expect(l.find_element_value(l.find_value_uri(value))).to eq value
+    expect(l.value?(value)).to eq true
+    expect(l.value?("DEFINITELY NON EXISTENT VALUE HOPEFULLY")).to eq false
   end
 
   it "should be able to compute count of different datasets" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      dataset_attribute = GoodData::Attribute['attr.commits.factsof']
-      attribute.create_metric(:attribute => dataset_attribute).execute.should == 3
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    dataset_attribute = @project.attributes('attr.commits.factsof')
+    expect(attribute.create_metric(:attribute => dataset_attribute).execute).to eq 3
   end
 
   it "should be able to tell you if a value is contained in a metric" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      label = attribute.primary_label
-      value = label.values.first
-      fact = GoodData::Fact['fact.commits.lines_changed']
-      metric = GoodData::Metric.xcreate("SELECT SUM([#{fact.uri}]) WHERE [#{attribute.uri}] = [#{value[:uri]}]")
-      metric.contain_value?(label, value[:value]).should == true
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    label = attribute.primary_label
+    value = label.values.first
+    fact = @project.facts('fact.commits.lines_changed')
+    metric = @project.create_metric("SELECT SUM([#{fact.uri}]) WHERE [#{attribute.uri}] = [#{value[:uri]}]")
+    expect(metric.contain_value?(label, value[:value])).to be true
   end
 
   it "should be able to replace the values in a metric" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      label = attribute.primary_label
-      value = label.values.first
-      different_value = label.values[1]
-      fact = GoodData::Fact['fact.commits.lines_changed']
-      metric = GoodData::Metric.xcreate("SELECT SUM([#{fact.uri}]) WHERE [#{attribute.uri}] = [#{value[:uri]}]")
-      metric.replace_value(label, value[:value], different_value[:value])
-      metric.contain_value?(label, value[:value]).should == false
-      metric.pretty_expression.should == "SELECT SUM([Lines Changed]) WHERE [Dev] = [josh@gooddata.com]"
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    label = attribute.primary_label
+    value = label.values.first
+    different_value = label.values[1]
+    fact = @project.facts('fact.commits.lines_changed')
+    metric = @project.create_metric("SELECT SUM([#{fact.uri}]) WHERE [#{attribute.uri}] = [#{value[:uri]}]")
+    metric.replace_value(label, value[:value], different_value[:value])
+    expect(metric.contain_value?(label, value[:value])).to be false
+    expect(metric.pretty_expression).to eq "SELECT SUM([Lines Changed]) WHERE [Dev] = [josh@gooddata.com]"
   end
 
   it "should be able to lookup the attributes by regexp and return a collection" do
-    GoodData.with_project(@project) do |p|
-      attrs = GoodData::Attribute.find_by_title(/Date/i)
-      attrs.count.should == 1
-    end
+    attrs = @project.attributes_by_title(/Date/i)
+    expect(attrs.count).to eq 1
   end
 
   it "should be able to give you values of the label as an array of hashes" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      label = attribute.primary_label
-      label.values.map {|v| v[:value]}.should == [
-        'jirka@gooddata.com',
-        'josh@gooddata.com',
-        'petr@gooddata.com',
-        'tomas@gooddata.com'
-      ]
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    label = attribute.primary_label
+    expect(label.values.map { |v| v[:value] }).to eq [
+      'jirka@gooddata.com',
+      'josh@gooddata.com',
+      'petr@gooddata.com',
+      'tomas@gooddata.com'
+    ]
   end
 
   it "should be able to give you values for" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      attribute.values_for(2).should == ["tomas@gooddata.com", "1"]
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    expect(attribute.values_for(2)).to eq ["tomas@gooddata.com", "1"]
   end
 
   it "should be able to find specific element and give you the primary label value" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      GoodData::Attribute.find_element_value("#{attribute.uri}/elements?id=2").should == 'tomas@gooddata.com'
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    expect(@project.find_attribute_element_value("#{attribute.uri}/elements?id=2")).to eq 'tomas@gooddata.com'
   end
 
   it "should be able to give you label by name" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      label = attribute.label_by_name('email')
-      label.label?.should == true
-      label.title.should == 'Email'
-      label.identifier.should == "label.devs.dev_id.email"
-      label.attribute_uri.should == attribute.uri
-      label.attribute.should == attribute
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    label = attribute.label_by_name('email')
+    expect(label.label?).to eq true
+    expect(label.title).to eq 'Email'
+    expect(label.identifier).to eq 'label.devs.dev_id.email'
+    expect(label.attribute_uri).to eq attribute.uri
+    expect(label.attribute).to eq attribute
   end
 
   it "should be able to return values of the attribute for inspection" do
-    GoodData.with_project(@project) do |p|
-      attribute = GoodData::Attribute['attr.devs.dev_id']
-      vals = attribute.values
-      vals.count.should == 4
-      vals.first.count.should == 2
-      vals.first.first[:value].should == "jirka@gooddata.com"
-    end
+    attribute = @project.attributes('attr.devs.dev_id')
+    vals = attribute.values
+    expect(vals.count).to eq 4
+    expect(vals.first.count).to eq 2
+    expect(vals.first.first[:value]).to eq "jirka@gooddata.com"
   end
 
   it "should be able to save_as a metric" do
-    GoodData.with_project(@project) do |p|
-      m = GoodData::Metric.find_first_by_title("My test metric")
-      cloned = m.save_as
-      m_cloned = GoodData::Metric.find_first_by_title("Clone of My test metric")
-      m_cloned.should == cloned
-      m_cloned.execute.should == cloned.execute
-    end
+    m = @project.metric_by_title("My test metric")
+    cloned = m.save_as
+    m_cloned = @project.metric_by_title("Clone of My test metric")
+    expect(m_cloned).to eq cloned
+    expect(m_cloned.execute).to eq cloned.execute
   end
 
   it "should be able to clone a project" do
-    GoodData.with_project(@project) do |p|
-      title = 'My new clone proejct'
-      cloned_project = p.clone(title: title, auth_token: ConnectionHelper::GD_PROJECT_TOKEN)
-      expect(cloned_project.title).to eq title
-      cloned_project.delete
-    end
+    title = 'My new clone proejct'
+    cloned_project = @project.clone(title: title, auth_token: ConnectionHelper::GD_PROJECT_TOKEN)
+    expect(cloned_project.title).to eq title
+    expect(cloned_project.facts.first.create_metric.execute).to eq 9
+    cloned_project.delete
+  end
+
+  it "should be able to clone a project without data" do
+    title = 'My new clone project'
+    cloned_project = @project.clone(title: title, auth_token: ConnectionHelper::GD_PROJECT_TOKEN, data: false)
+    expect(cloned_project.title).to eq title
+    expect(cloned_project.facts.first.create_metric.execute).to eq nil
+    cloned_project.delete
   end
 end