gooddata 0.6.24 → 0.6.25

data/spec/integration/blueprint_with_grain_spec.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 'Create project using GoodData client', :constraint => 'slow' do
+  before(:all) do
+    @client = ConnectionHelper.create_default_connection
+    @blueprint = GoodData::Model::ProjectBlueprint.build("My project from blueprint") do |p|
+      p.add_date_dimension('created_on')
+
+      p.add_dataset('dataset.users') do |d|
+        d.add_anchor('attr.users.id', grain: [{ date: 'created_on' }, { attribute: 'attribute.user' }])
+        d.add_date('created_on')
+        d.add_attribute('attribute.user')
+        d.add_label('label.user.email', reference: 'attribute.user')
+        d.add_fact('fact.users.some_number')
+      end
+    end
+    @blueprint.valid? # => true
+
+    @project = @client.create_project_from_blueprint(@blueprint, auth_token: ConnectionHelper::GD_PROJECT_TOKEN)
+  end
+
+  after(:all) do
+    @project.delete
+    @client.disconnect
+  end
+
+  it 'Should load the data with grain' do
+    data = [
+      ['created_on', 'label.user.email', 'fact.users.some_number'],
+      ['01/01/2011', 'thomas', '1'],
+      ['01/01/2011', 'thomas', '2'],
+      ['01/01/2011', 'jim', '2'],
+      ['01/01/2011', 'peter', '2'],
+      ['01/01/2011', 'john', '3']]
+    @project.upload(data, @blueprint, 'dataset.users')
+
+    expect(@project.blueprint.datasets.first.count(@project)).to eq 4
+  end
+
+  it 'Should be able to remove grain and load the same data' do
+    updated_blueprint = GoodData::Model::ProjectBlueprint.build("My project from blueprint") do |p|
+      p.add_date_dimension('created_on')
+
+      p.add_dataset('dataset.users') do |d|
+        d.add_anchor('attr.users.id')
+        d.add_date('created_on')
+        d.add_attribute('attribute.user')
+        d.add_label('label.user.email', reference: 'attribute.user')
+        d.add_fact('fact.users.some_number')
+      end
+    end
+
+    @project.update_from_blueprint(updated_blueprint)
+
+    data = [
+      ['created_on', 'label.user.email', 'fact.users.some_number'],
+      ['01/01/2011', 'thomas', '1'],
+      ['01/01/2011', 'thomas', '2'],
+      ['01/01/2011', 'jim', '2'],
+      ['01/01/2011', 'peter', '2'],
+      ['01/01/2011', 'john', '3']]
+    @project.upload(data, @blueprint, 'dataset.users')
+
+    expect(@project.blueprint.datasets.first.count(@project)).to eq 5
+  end
+end

data/spec/integration/clients_spec.rb

@@ -0,0 +1,135 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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/segment'
+require 'securerandom'
+
+describe GoodData::Client do
+  TOKEN = 'mustangs'
+
+  before(:all) do
+    @client = GoodData.connect('mustang@gooddata.com', 'jindrisska', server: 'https://mustangs.intgdc.com', verify_ssl: false )
+    @domain = @client.domain('mustangs')
+    @master_project = @client.create_project(title: 'Test project', auth_token: TOKEN)
+    @segment_name = "segment-#{SecureRandom.uuid}"
+    @segment = @domain.create_segment(segment_id: @segment_name, master_project: @master_project)
+  end
+
+  after(:all) do
+    @segment && @segment.delete
+    @master_project && @master_project.delete
+    @client.disconnect
+  end
+
+  describe '#[]' do
+    before(:all) do
+      client_id = SecureRandom.uuid
+      @client_project = @client.create_project(title: "client_#{client_id} project", auth_token: TOKEN)
+      @segment_client = @segment.create_client(id: "tenant_#{client_id}", project: @client_project)
+    end
+
+    it 'Returns all clients of a segment' do
+      clients = @segment.clients
+      expect(clients.to_a).to be_an_instance_of(Array)
+      expect(clients.to_a.count).to eq 1
+    end
+
+    it 'Returns specific tenant when schedule ID passed' do
+      client = @segment.clients(@segment_client.uri)
+      expect(client).to be_an_instance_of(GoodData::Client)
+      expect(client.uri).to eq @segment_client.uri
+    end
+
+    after(:all) do
+      @segment_client && @segment_client.delete
+      @client_project && @client_project.delete
+    end
+
+  end
+
+  describe '#delete' do
+    before(:all) do
+      client_id = SecureRandom.uuid
+      @segment_client = @segment.create_client(id: "tenant_#{client_id}")
+    end
+
+    it 'Deletes particular client' do
+      expect(@segment.clients.count).to eq 1
+      s = @segment.clients(@segment_client.uri)
+      s.delete
+      expect(@segment.clients.count).to eq 0
+      @segment_client = nil
+    end
+
+    after(:all) do
+      @segment_client && @segment_client.delete
+    end
+  end
+
+  describe '#delete' do
+    before(:all) do
+      client_id = SecureRandom.uuid
+      @client_project = @client.create_project(title: 'client_1 project', auth_token: TOKEN)
+      @segment_client = @segment.create_client(id: "tenant_#{client_id}", project: @client_project)
+    end
+
+    it 'Deletes particular client. Project is cleaned up as well' do
+      expect(@segment.clients.count).to eq 1
+      s = @segment.clients(@segment_client.uri)
+      s.delete
+      expect(@segment.clients.count).to eq 0
+      expect(@client_project.reload!.state).to eq :deleted
+      @segment_client = nil
+    end
+
+    after(:all) do
+      @segment_client && segment_client.delete
+    end
+  end
+
+  describe '#save' do
+    before(:all) do
+      @client_id = SecureRandom.uuid
+      @client_project = @client.create_project(title: 'client_1 project', auth_token: TOKEN)
+      @segment_client = @segment.create_client(id: "tenant_#{@client_id}", project: @client_project)
+    end
+
+    it 'can update project id' do
+      begin
+        other_client_project = @client.create_project(title: "client_#{@client_id} other project", auth_token: TOKEN)
+        @segment_client.project = other_client_project
+        @segment_client.save
+        expect(@segment.clients('tenant_1').project_uri).to eq other_client_project.uri
+      ensure
+        other_client_project && other_client_project.delete
+      end
+    end
+
+    it 'can update tenants segment id' do
+      pending 'Fix the test '
+
+      second_segment_name = "segment-#{SecureRandom.uuid}"
+      second_master_project = @client.create_project(title: 'Test project', auth_token: TOKEN)
+      second_segment = @domain.create_segment(segment_id: second_segment_name, master_project: second_master_project)
+      @segment_client.segment = second_segment
+      @segment_client.save
+      expect(second_segment.clients.find { |s| s.uri == @segment_client.uri }).not_to be_nil
+      expect(@segment.clients.find { |s| s.uri == @segment_client.uri }).to be_nil
+    end
+
+    it 'cannot update a client id' do
+      @segment_client.client_id = 'different_id'
+      expect {
+        @segment_client.save
+      }.to raise_error RestClient::BadRequest
+    end
+
+    after(:all) do
+      @segment_client && @segment_client.delete
+      @client_project && @client_project.delete
+    end
+  end
+end

data/spec/integration/date_dim_switch_spec.rb

@@ -0,0 +1,142 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 "Swapping a date dimension and exchanging all attributes/elements", :constraint => 'slow' do
+  before(:all) do
+    @client = ConnectionHelper::create_default_connection
+    @blueprint = GoodData::Model::ProjectBlueprint.build("My project from blueprint") do |p|
+      p.add_date_dimension('created_on')
+      p.add_date_dimension('created_on_2')
+
+      p.add_dataset('dataset.users') do |d|
+        d.add_anchor('attr.users.id')
+        d.add_label('label.users.id', reference: 'attr.users.id')
+        d.add_date('created_on')
+        d.add_fact('fact.users.some_number')
+      end
+    end
+
+    # Create a project
+    @project = @client.create_project_from_blueprint(@blueprint, token: ConnectionHelper::GD_PROJECT_TOKEN, environment: ProjectHelper::ENVIRONMENT)
+
+    # Load data
+    users_data = [
+      ["label.users.id", "created_on", "fact.users.some_number"],
+      [1,"01/01/2014",1],
+      [2,"10/15/2014",2],
+      [3,"05/02/2014",3]
+    ]
+    @project.upload(users_data, @blueprint, 'dataset.users')
+
+  end
+
+  after(:all) do
+    @project.delete unless @project.nil?
+
+    @client.disconnect
+  end
+
+  it "should swap the dimension, exhcange all stuff and not break anything" do
+
+    # WE have 2 date dims
+    expect(@blueprint.date_dimensions.map(&:id)).to eq ["created_on", "created_on_2"]
+    # One is connected
+    expect(@blueprint.datasets.flat_map(&:references).map(&:reference).include?('created_on')).to be_truthy
+    # The other is disconnected
+    expect(@blueprint.datasets.flat_map(&:references).map(&:reference).include?('created_on_2')).to be_falsey
+
+    
+    # Create a metric
+    @metric_1 = @project.attributes('created_on.date').create_metric(title: 'Count of days in DD')
+    @metric_1.save
+
+    # Create a report
+    @report = @project.create_report(left: @metric_1, top: ['created_on.date'], title: 'Beautiful report')
+    @report.save
+
+    def suggest_mapping(label_a, label_b, project)
+      as = project.attributes
+      a1 = as.select {|a| a.identifier.include?("#{label_a}.")}.pmapcat { |a| [a] + a.labels }
+      a2 = as.select {|a| a.identifier.include?("#{label_b}.")}.pmapcat { |a| [a] + a.labels }
+      a1.reduce({}) do |a, e|
+        match = a2.find { |l| l.identifier.gsub(/^#{label_b}/, '') == e.identifier.gsub(/^#{label_a}/, '') }
+        a[e.identifier] = match && match.identifier
+        a
+      end
+    end
+
+    # Create definition with report specific metric
+    @metric_2 = @project.attributes('created_on.date').create_metric(title: 'Count of days in DD Secret')
+    @metric_2.deprecated = true
+    @metric_2.save
+    @report_with_private = @project.create_report({
+      left: @metric_2,
+      top: ['created_on.day.in.week'],
+      title: 'Beautiful report with private'
+    })
+    @report_with_private.save
+
+    # Create a definition with a filter value
+    @report = @project.create_report({
+      left: @metric_2,
+      top: ['created_on.quarter'],
+      filters: [['created_on.year', 2015, 2016]],
+      title: 'Beautiful report with filters'
+    })
+    @report.save
+
+    @label = @project.labels('created_on.year').primary_label
+    @variable = @project.create_variable(title: 'uaaa', attribute: @label.attribute).save    
+    filters = [[ConnectionHelper::DEFAULT_USERNAME, @label.uri, '2015', '2016']]
+    @project.add_variable_permissions(filters, @variable)
+    
+    as = @project.attributes.select {|a| a.identifier.include?('created_on_2.')}
+    expect(as.pmapcat {|a| a.usedby('report')}).to be_empty
+    expect(as.pmapcat {|a| a.usedby('metric')}).to be_empty
+    expect(as.pmapcat {|a| a.usedby('dashboard')}).to be_empty
+
+    # replace values
+    mapping = GoodData::Helpers.prepare_mapping(suggest_mapping('created_on', 'created_on_2', @project), project: @project)
+    @project.replace_from_mapping(mapping)
+
+    # Check if any of the attributes is used by any of the objects. All should be empty
+    as = @project.attributes.select {|a| a.identifier.include?('created_on.')}
+    expect(as.pmapcat {|a| a.usedby('report')}).to be_empty
+    expect(as.pmapcat {|a| a.usedby('metric')}).to be_empty
+    expect(as.pmapcat {|a| a.usedby('dashboard')}).to be_empty
+
+    # Reload stuff
+    @metric_2.reload!
+    @report.reload!
+    @report_with_private.reload!
+
+    # Stuff should be still computable
+    @metric_2.execute
+    @report.execute
+    @report_with_private.execute
+
+    # Labels 
+    GoodData::SmallGoodZilla.get_uris(@metric_2.expression)
+    expect(@report.definition.attributes.map(&:identifier)).to eq ["created_on_2.quarter"]
+    ids = GoodData::SmallGoodZilla.get_uris(@report.definition.filters.first).map { |x| x.split('/')[-2..-1].join('/') }
+    expect(ids).to eq ["obj/2286", "2286/elements?id=2015", "2286/elements?id=2016"]
+
+    ids = GoodData::SmallGoodZilla.get_uris(@report.definition.filters.first).map { |x| x.split('/')[-2..-1].join('/') }
+    expect(ids).to eq ["obj/2286", "2286/elements?id=2015", "2286/elements?id=2016"]
+
+    ids = GoodData::SmallGoodZilla.get_uris(@variable.values.first.expression).map {|v| v.split('/')[-2..-1].join('/')}
+    expect(ids).to eq ["obj/2286", "2286/elements?id=2015", "2286/elements?id=2016"]
+
+    # Swap the dims
+    bp = @project.blueprint
+    bp.swap_date_dimension!('created_on', 'created_on_2')
+    @project.update_from_blueprint(bp)
+    expect(bp.datasets.flat_map(&:references).map(&:reference).include?('created_on')).to be_falsey
+    expect(bp.datasets.flat_map(&:references).map(&:reference).include?('created_on_2')).to be_truthy
+  end
+end

data/spec/integration/full_project_spec.rb

@@ -226,6 +226,7 @@ describe "Full project implementation", :constraint => 'slow' do
     expect(r.locked?).to eq true
     r.unlock!
     expect(r.locked?).to eq false
+    r.delete
   end
 
   it "should be able to purge report from older revisions" do
@@ -365,7 +366,7 @@ describe "Full project implementation", :constraint => 'slow' do
     fact = @project.fact_by_title('Lines Changed')
     expect(fact.tags.empty?).to be_truthy
 
-    fact.tags = "tag1,tag2,tag3"
+    fact.tags = "tag1 tag2 tag3"
     fact.save
 
     tagged_facts = GoodData::Fact.find_by_tag('tag3', :client => @client, :project => @project)
@@ -413,8 +414,7 @@ describe "Full project implementation", :constraint => 'slow' do
 
     expect(metric.contain?(attribute)).to be true
     expect(metric.contain?(repo_attribute)).to be false
-
-    metric.replace(attribute, repo_attribute)
+    metric.replace!(attribute => repo_attribute)
     metric.save
     expect(metric.execute).not_to eq 4
 

data/spec/integration/project_spec.rb

@@ -207,6 +207,26 @@ describe GoodData::Project, :constraint => 'slow' do
       expect(logins.map {|l| users.find {|u| u.login == l}}.pmap {|u| u.role.title}).to eq roles.flatten
       
     end
+
+    it 'can work with groups as well. Groups have to be set up. It can only eat hashes on input in this case' do
+      users = (1..5).to_a.map { |x| ProjectHelper.create_random_user(@client).to_hash }
+      group_names = ['group_1', 'group_2']
+      groups = group_names.map { |g| @project.create_group(name: g) }
+      users_with_groups = users.map { |u| u[:user_group] = groups.take(rand(2) + 1).map(&:name); u}
+      @domain.create_users(users_with_groups, domain: @domain)
+      @project.import_users(users_with_groups, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+      expect(users_with_groups.flat_map { |u| u[:user_group].map { |g| [u[:login], g] } }.all? do |u, g|
+        @project.user_groups(g).member?(@project.member(u).uri) rescue false
+      end).to be_truthy
+
+      users_with_group = users.map { |u| u[:user_group] = ['group_1']; u}
+      to_whitelist = @project.user_groups('group_2').members.to_a.sample
+      @project.import_users(users_with_group, domain: @domain, whitelists: [to_whitelist.login, /gem_tester@gooddata.com/])
+      expect(@project.user_groups('group_2').members.map(&:login)).to eq [to_whitelist.login]
+      expect(users_with_group.flat_map { |u| u[:user_group].map { |g| [u[:login], g] } }.all? do |u, g|
+        @project.user_groups(g).member?(@project.member(u).uri) rescue false
+      end).to be_truthy
+    end
   end
 
   describe '#summary' do

data/spec/integration/segments_spec.rb

@@ -0,0 +1,141 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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/segment'
+require 'securerandom'
+
+describe GoodData::Segment do
+  TOKEN = 'mustangs'
+
+  before(:all) do
+    @client = GoodData.connect('mustang@gooddata.com', 'jindrisska', server: 'https://mustangs.intgdc.com', verify_ssl: false )
+    @domain = @client.domain('mustangs')
+  end
+
+  before(:each) do
+    @uuid = SecureRandom.uuid
+    @master_project = @client.create_project(title: "Test MASTER project for #{@uuid}", auth_token: TOKEN)
+    @segment_name = "segment-#{@uuid}"
+    @segment = @domain.create_segment(segment_id: @segment_name, master_project: @master_project)
+  end
+
+  after(:each) do
+    @segment && @segment.delete(force: true)
+  end
+
+  after(:all) do
+    @master_project.delete if @master_project
+    @client.disconnect
+  end
+
+  describe '#[]' do
+    it 'Returns all segments when :all passed' do
+      res = @domain.segments
+      expect(res).to be_an_instance_of(Array)
+    end
+
+    it 'Returns specific segment when segment ID passed' do
+      s = @domain.segments(@segment_name)
+      @segment.uri == s.uri
+      expect(s).to be_an_instance_of(GoodData::Segment)
+      expect(@segment).to be_an_instance_of(GoodData::Segment)
+    end
+  end
+
+  describe '#delete' do
+    it 'Deletes particular segment' do
+      old_count = @domain.segments.count
+      s = @domain.segments(@segment_name)
+      s.delete
+      expect(@domain.segments.length).to eq (old_count - 1)
+      # prevent delete attempt in the after hook
+      @segment = nil
+    end
+  end
+
+  describe '#save' do
+    it 'can update a segment master project' do
+      different_master = @client.create_project(title: 'Test project', auth_token: TOKEN)
+      @segment.master_project = different_master
+      @segment.save
+      @segment = @domain.segments(@segment_name)
+      expect(@segment.master_project_uri).not_to eq @master_project.uri
+      expect(@segment.master_project_uri).to eq different_master.uri
+    end
+
+    it 'cannot update a segment id' do
+      @segment.segment_id = 'different_id'
+      expect {
+        @segment.save
+      }.to raise_error RestClient::BadRequest
+    end
+  end
+
+  describe '#create_client' do
+    it 'can create a new client in a segment' do
+      begin
+        client_project = @client.create_project(title: 'client_1 project', auth_token: TOKEN)
+        segment_client = @segment.create_client(id: 'tenant_1', project: client_project)
+        expect(segment_client).to be_an_instance_of(GoodData::Client)
+        expect(@segment.clients.count).to eq 1
+      ensure
+        segment_client && segment_client.delete
+      end
+    end
+  end
+
+  describe '#provision_client_projects' do
+    it 'can create a new client in a segment without project and then provision' do
+      begin
+        segment_client = @segment.create_client(id: 'tenant_1')
+        expect(segment_client).to be_an_instance_of(GoodData::Client)
+        expect(@segment.clients.count).to eq 1
+        @domain.synchronize_clients
+        @domain.provision_client_projects
+        expect(@domain.segments.flat_map { |s| s.clients.to_a }.all?(&:project?)).to be_truthy
+      ensure
+        segment_client && segment_client.delete
+      end
+    end
+  end
+
+  describe '#update_clients' do
+    it 'can create a new client in a segment without project and then provision' do
+      begin
+        uuid_2 = SecureRandom.uuid
+        master_project_2 = @client.create_project(title: "Test MASTER project for #{uuid_2}", auth_token: TOKEN)
+        segment_name_2 = "segment-#{uuid_2}"
+        segment_2 = @domain.create_segment(segment_id: segment_name_2, master_project: master_project_2)
+
+        client_1 = "client-#{SecureRandom.uuid}"
+        client_2 = "client-#{SecureRandom.uuid}"
+        data = [{id: client_1, segment: segment_name_2 },
+                {id: client_2, segment: @segment_name }]
+        res = @domain.update_clients(data)
+        expect(@domain.segments.map(&:id)).to include(@segment.id, segment_2.id)
+        expect(@domain.segments.pmapcat {|s| s.clients.to_a }.map(&:id)).to include(client_1, client_2)
+
+        client_3 = "client-#{SecureRandom.uuid}"
+        client_4 = "client-#{SecureRandom.uuid}"
+        data = [{id: client_3, segment: segment_name_2 },
+                {id: client_4, segment: @segment_name }]
+        res = @domain.update_clients(data)
+        expect(@domain.segments.pmapcat {|s| s.clients.to_a }.map(&:id)).to include(client_1, client_2, client_3, client_4)
+
+        # bring the projects
+        @domain.synchronize_clients
+        @domain.provision_client_projects
+        projects_to_delete = @domain.segments.pmapcat {|s| s.clients.to_a }.select { |c| [client_1, client_2].include?(c.id) }.map(&:project)
+        res = @domain.update_clients(data, delete_extra: true)
+        expect(@domain.segments.pmapcat {|s| s.clients.to_a }.map(&:id)).to include(client_3, client_4)
+        expect(@domain.segments.pmapcat {|s| s.clients.to_a }.map(&:id)).not_to include(client_1, client_2)
+        expect(projects_to_delete.pmap(&:reload!).map(&:state)).to eq [:deleted, :deleted]
+      ensure
+        segment_2.delete(force: true) if segment_2
+      end
+    end
+  end
+end