gooddata 0.6.53 → 0.6.54

data/spec/unit/actions/synchronize_user_groups_spec.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'gooddata/lcm/lcm2'
+require 'gooddata/lcm/actions/synchronize_user_groups'
+
+describe GoodData::LCM2::SynchronizeUserGroups do
+  let(:gdc_gd_client) { double(:gdc_gd_client) }
+  let(:development_client) { double(:development_client) }
+  let(:logger) { double(:logger) }
+
+  let(:from_project) { double(:from_project) }
+  let(:to_project) { double(:to_project) }
+
+  let(:params) do
+    params = {
+      gdc_gd_client: gdc_gd_client,
+      development_client: development_client,
+      synchronize: [{
+        segment_id: 'some_segment_ids',
+        from: 'from_project_id',
+        to: [{ pid: 'to_project_id' }]
+      }],
+      gdc_logger: logger
+    }
+    GoodData::LCM2.convert_to_smart_hash(params)
+  end
+
+  before do
+    allow(logger).to receive(:info)
+
+    allow(development_client).to receive(:projects) { from_project }
+    allow(from_project).to receive(:title)
+    allow(from_project).to receive(:pid)
+
+    allow(gdc_gd_client).to receive(:projects) { to_project }
+    allow(to_project).to receive(:title)
+    allow(to_project).to receive(:pid)
+  end
+
+  it 'should transfer user groups' do
+    result = [{ from: 'from_project_id', to: 'to_project_id', user_group: 'user_group_name', status: 'created' }]
+    expect(GoodData::Project).to receive(:transfer_user_groups).with(from_project, to_project).and_return(result)
+    subject.class.call(params)
+  end
+end

data/spec/unit/actions/synchronize_users_spec.rb

@@ -0,0 +1,76 @@
+require 'active_support/core_ext/hash'
+require 'gooddata/lcm/lcm2'
+require_relative 'shared_examples_for_user_actions'
+
+describe GoodData::LCM2::SynchronizeUsers do
+  let(:client) { double('client') }
+  let(:user) { double('user') }
+  let(:data_source) { double('user') }
+  let(:domain) { double('domain') }
+  let(:project) { double('project') }
+  let(:organization) { double('organization') }
+  let(:logger) { double('logger') }
+
+  before do
+    allow(client).to receive(:projects).and_return(project)
+    allow(client).to receive(:user).and_return(user)
+    allow(client).to receive(:domain).and_return(domain)
+    allow(domain).to receive(:clients).and_return(organization)
+    allow(organization).to receive(:project_uri)
+    allow(project).to receive(:import_users).and_return([{}])
+    allow(project).to receive(:metadata).and_return({})
+    allow(project).to receive(:uri)
+    allow(project).to receive(:pid).and_return('123456789')
+    allow(data_source).to receive(:realize)
+    allow(user).to receive(:login).and_return('my_login')
+    allow(GoodData::Helpers::DataSource).to receive(:new)
+      .and_return(data_source)
+    allow(logger).to receive(:debug)
+  end
+
+  context 'when multiple_projects_column not specified' do
+    context 'when mode requires client_id' do
+      let(:params) do
+        params = {
+          GDC_GD_CLIENT: client,
+          input_source: 'foo',
+          domain: 'bar',
+          gdc_logger: logger,
+          sync_mode: 'sync_one_project_based_on_custom_id'
+        }
+        GoodData::LCM2.convert_to_smart_hash(params)
+      end
+
+      it_behaves_like 'a user action' do
+        let(:client_id) { '123456789' }
+      end
+    end
+
+    context 'when mode requires client_id' do
+      let(:params) do
+        params = {
+          GDC_GD_CLIENT: client,
+          input_source: 'foo',
+          domain: 'bar',
+          gdc_logger: logger,
+          sync_mode: 'sync_one_project_based_on_pid'
+        }
+        GoodData::LCM2.convert_to_smart_hash(params)
+      end
+
+      before do
+        allow(File).to receive(:open).and_return("project_id\n123456789")
+      end
+
+      it 'uses project_id column' do
+        expect(project).to receive(:import_users) do |filtered_users|
+          filtered_users.each do |u|
+            expect(u[:pid]).to eq '123456789'
+          end
+          []
+        end
+        subject.class.call(params)
+      end
+    end
+  end
+end

data/spec/unit/helpers/data_helper_spec.rb

@@ -7,6 +7,8 @@
 require 'gooddata/helpers/data_helper'
 
 describe GoodData::Helpers::DataSource do
+  let(:file_size) { 666 }
+
   before :each do
     @s3_client = double('s3_client')
     @bucket = double('bucket')
@@ -15,6 +17,8 @@ describe GoodData::Helpers::DataSource do
     allow(@s3_client).to receive(:bucket) { @bucket }
     allow(@bucket).to receive(:object) { @objects }
     allow(@objects).to receive(:get) { StringIO.new('aaa') }
+    allow(@objects).to receive(:size) { file_size }
+    allow(File).to receive(:size) { file_size }
 
     @ds = GoodData::Helpers::DataSource.new(type: :s3, bucket: 'some_bucket', key: 'some_key')
   end
@@ -47,4 +51,17 @@ describe GoodData::Helpers::DataSource do
       ds.realize(params)
     end.to raise_exception 'Key "key" is missing in S3 datasource'
   end
+
+  context 'when size of the downloaded file is not right' do
+    before do
+      allow(File).to receive(:size) { 0 }
+    end
+
+    it 'raises an error' do
+      params = { 'aws_client' => { 's3_client' => @s3_client } }
+      expect do
+        @ds.realize(params)
+      end.to raise_exception(/Expected size 666, got 0/)
+    end
+  end
 end

data/spec/unit/helpers/global_helpers_spec.rb

@@ -123,6 +123,22 @@ describe GoodData::Helpers do
       end
     end
 
+    it 'should not throw error if missing reference parameter placeholder' do
+      params = {
+        'x' => 'y',
+        'ads_password' => 'ads_123',
+        'gd_encoded_params' => '{"login_username": "login_user", "login_password": "${my_password}"}'
+      }
+      expected_result = {
+        'x' => 'y',
+        'ads_password' => 'ads_123',
+        'login_username' => 'login_user',
+        'login_password' => '${my_password}'
+      }
+      result = GoodData::Helpers.decode_params(params, :resolve_reference_params => true)
+      expect(result).to eq(expected_result)
+    end
+
     it 'should encode reference parameters in gd_encoded_params' do
       params = {
         'x' => 'y',

data/spec/unit/helpers_spec.rb

@@ -38,12 +38,6 @@ describe GoodData::Helpers do
     end
   end
 
-  describe '#find_goodfile' do
-    it 'works' do
-      GoodData::Helpers.find_goodfile.should_not be_nil
-    end
-  end
-
   describe "#decode_params" do
     it 'decodes the data params from json' do
       params = {

data/spec/unit/models/blueprint/project_blueprint_spec.rb

@@ -99,12 +99,29 @@ describe GoodData::Model::ProjectBlueprint do
 
     it 'invalid blueprint should give you list of violating references' do
       errors = @invalid_blueprint.validate
-      expect(errors.size).to eq 1
-      expect(errors).to eq([
+      expect(errors.size).to eq 5
+      expect(errors).to match_array([
         {
           :type => :wrong_label_reference,
           :label => "some_label_id",
           :wrong_reference => "attr.repos.repo_id                 ERROR"
+        },
+        {
+          type: :invalid_identifier,
+          id: 'some_attr_id(hello)'
+        },
+        {
+          type: :duplicated_identifier,
+          id: 'some_label_id'
+        },
+        {
+          type: :wrong_label_reference,
+          label: "some_label_id",
+          wrong_reference: "some_attr_id"
+        },
+        {
+          type: :attribute_without_label,
+          attribute: "some_attr_id(hello)"
         }
       ])
     end
@@ -417,7 +434,7 @@ describe GoodData::Model::ProjectBlueprint do
         d.add_date('opportunity_comitted', dataset: 'committed_on')
       end
     end
-    expect(bp.datasets.flat_map { |d| d.find_columns_by_type(:date) }.map(&:format)).to eq [GoodData::Model::DEFAULT_DATE_FORMAT]
+    expect(bp.datasets.flat_map { |d| d.find_columns_by_type(:date) }.map { |d| d.data[:format] }).to eq [GoodData::Model::DEFAULT_DATE_FORMAT]
   end
 
   it 'blueprint can be set with explicit date' do
@@ -435,7 +452,7 @@ describe GoodData::Model::ProjectBlueprint do
       end
     end
     expect(bp.valid?).to be_truthy
-    expect(bp.datasets.flat_map { |d| d.find_columns_by_type(:date) }.map(&:format)).to eq ['yyyy/MM/dd']
+    expect(bp.datasets.flat_map { |d| d.find_columns_by_type(:date) }.map { |d| d.data[:format] }).to eq ['yyyy/MM/dd']
   end
 
   describe '#remove' do

data/spec/unit/models/project_creator_spec.rb

@@ -71,4 +71,20 @@ describe GoodData::Model::ProjectCreator do
       GoodData::Model::ProjectCreator.pick_correct_chunks(@data, update_preference: { cascade_drops: true, preserve_data: false, unmeetable_condition: true })
     end.to raise_error
   end
+
+  it 'should pick correct update chunks based on new parameter "allow_cascade_drops" in your preference' do
+    chunk = GoodData::Model::ProjectCreator.pick_correct_chunks(@data, update_preference: { allow_cascade_drops: false })
+    expect(chunk).to eq [@chunk_a]
+  end
+
+  it 'should pick correct update chunks based on new parameter "keep_data" in your preference' do
+    chunk = GoodData::Model::ProjectCreator.pick_correct_chunks(@data, update_preference: { keep_data: false })
+    expect(chunk).to eq [@chunk_a, @chunk_b]
+  end
+
+  it 'should raise error when mixing new parameters with the old ones in your preference' do
+    expect do
+      GoodData::Model::ProjectCreator.pick_correct_chunks(@data, update_preference: { allow_cascade_drops: true, cascade_drops: false })
+    end.to raise_error('Please do not mix old parameters (:cascade_drops, :preserve_data) with the new ones (:allow_cascade_drops, :keep_data).')
+  end
 end

data/spec/unit/models/project_spec.rb

@@ -4,221 +4,90 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-require 'gooddata'
-
-describe GoodData::Project, :constraint => 'slow' do
-  before(:all) do
-    @client = ConnectionHelper.create_default_connection
-    @project = ProjectHelper.get_default_project(:client => @client)
-    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+shared_examples 'a blueprint provider' do
+  it 'requests model view with includeCA=true' do
+    expect(client).to receive(:get).with(
+      '/gdc/projects/foo/model/view',
+      hash_including(params: hash_including(includeCA: true))
+    )
+    subject.blueprint(include_ca: true)
   end
+end
 
-  after(:all) do
-    @client.disconnect
+describe GoodData::Project do
+  subject { GoodData::Project }
+  let(:from_project) { double('from_project') }
+  let(:to_project) { double('to_project') }
+  let(:process) { double('process') }
+  let(:add) { double('add') }
+  let(:output_stage) { double('output_stage') }
+  let(:client) { double('client') }
+  let(:connection) { double('connection') }
+  let(:server) { double('server') }
+
+  before do
+    allow(from_project).to receive(:processes).and_return([process])
+    allow(to_project).to receive(:processes).and_return([])
+    allow(process).to receive(:type).and_return(:dataload)
+    allow(to_project).to receive(:add).and_return(add)
+    allow(to_project).to receive(:client).and_return(client)
+    allow(client).to receive(:connection).and_return(connection)
+    allow(connection).to receive(:server).and_return(server)
+    allow(from_project).to receive(:add).and_return(add)
+    allow(from_project).to receive(:client).and_return(client)
+    allow(add).to receive(:output_stage).and_return(output_stage)
   end
 
-  describe 'projects' do
-    it 'Can get all projects' do
-      projects = @client.projects
-      expect(projects).to_not be_nil
-      expect(projects).to be_a_kind_of(Array)
-      projects.pmap do |project|
-        expect(project).to be_an_instance_of(GoodData::Project)
+  describe '.transfer_output_stage' do
+    context 'when source and target domains are different' do
+      before do
+        allow(server).to receive(:url).and_return('foo', 'bar')
       end
-    end
-
-    it 'Returns project if ID passed' do
-      expect(@project).to_not be_nil
-      expect(@project).to be_a_kind_of(GoodData::Project)
-      expect(@project.pid).to eq @project.pid
-    end
-
-    it 'Returns project if URL passed' do
-      expect(@project).to_not be_nil
-      expect(@project).to be_a_kind_of(GoodData::Project)
-      expect(@project.pid).to eq @project.pid
-    end
-
-    it 'Throws an exception when invalid format of URL passed' do
-      invalid_url = '/gdc/invalid_url'
-      expect { GoodData::Project[invalid_url] }.to raise_error
-    end
-  end
-
-  describe '#all' do
-    it 'Returns all projects' do
-      projects = GoodData::Project.all(:client => @client)
-      expect(projects).to_not be_nil
-      expect(projects).to be_a_kind_of(Array)
-    end
-  end
-
-  describe '#get_role_by_identifier' do
-    it 'Looks up for role by identifier' do
-      role = @project.get_role_by_identifier('readOnlyUserRole')
-      expect(role).to_not be_nil
-      expect(role).to be_a_kind_of(GoodData::ProjectRole)
-    end
-  end
 
-  describe '#get_role_by_summary' do
-    it 'Looks up for role by summary' do
-      role = @project.get_role_by_summary('read only user role')
-      expect(role).to_not be_nil
-      expect(role).to be_a_kind_of(GoodData::ProjectRole)
-    end
-  end
-
-  describe '#get_role_by_title' do
-    it 'Looks up for role by title' do
-      role = @project.get_role_by_title('Viewer')
-      expect(role).to_not be_nil
-      expect(role).to be_a_kind_of(GoodData::ProjectRole)
-    end
-  end
-
-  describe "#member" do
-    it 'Returns GoodData::Membership when looking for existing user using login' do
-      res = @project.get_user(ConnectionHelper::DEFAULT_USERNAME)
-      expect(res).to be_instance_of(GoodData::Membership)
-    end
-
-    it 'Returns GoodData::Membership when looking for existing user using URL' do
-      res = @project.get_user(ConnectionHelper::DEFAULT_USER_URL)
-      expect(res).to be_instance_of(GoodData::Membership)
-    end
-
-    it 'Returns GoodData::Membership when looking for existing user using GoodData::Profile' do
-      user = @project.members.first
-      res = @project.get_user(user)
-      expect(res).to be_instance_of(GoodData::Membership)
-    end
-
-    it 'Returns null for non-existing user' do
-      res = @project.get_user(ConnectionHelper::TEST_USERNAME)
-      expect(res).to be_nil
-    end
-  end
-
-  describe "#member?" do
-    it 'Returns true when looking for existing user using login' do
-      res = @project.member?(ConnectionHelper::DEFAULT_USERNAME)
-      expect(res).to be_truthy
-    end
-
-    it 'Returns true when looking for existing user using URL' do
-      res = @project.member?(ConnectionHelper::DEFAULT_USER_URL)
-      expect(res).to be_truthy
-    end
-
-    it 'Returns true when looking for existing user using GoodData::Profile' do
-      user = @project.members.first
-      res = @project.member?(user)
-      expect(res).to be_truthy
-    end
-
-    it 'Returns false for non-existing user' do
-      res = @project.member?(ConnectionHelper::TEST_USERNAME)
-      expect(res).to be_falsey
-    end
-
-    it 'Returns true for existing user when using optional list' do
-      list = @project.members
-      res = @project.member?(ConnectionHelper::DEFAULT_USERNAME, list)
-      expect(res).to be_truthy
-    end
-
-    it 'Returns false for non-existing user when using optional list' do
-      list = []
-      res = @project.member?(ConnectionHelper::DEFAULT_USERNAME, list)
-      expect(res).to be_falsey
-    end
-  end
-
-  describe '#members?' do
-    it 'Returns array of bools when looking for existing users using GoodData::Profile' do
-      users = @project.members.take(10)
-      res = @project.members?(users)
-      expect(res.all?).to be_truthy
-    end
-
-    it 'Support variety of inputs' do
-      users = @project.members.take(1)
-      res = @project.members?(users + [ConnectionHelper::TEST_USERNAME])
-      expect(res).to eq [true, false]
-    end
-  end
-
-  describe '#roles' do
-    it 'Returns array of GoodData::ProjectRole' do
-      roles = @project.roles
-      expect(roles).to be_instance_of(Array)
-
-      roles.each do |role|
-        expect(role).to be_instance_of(GoodData::ProjectRole)
+      it 'raises an error' do
+        expect { subject.transfer_output_stage(from_project, to_project, {}) }
+          .to raise_error(/Cannot transfer output stage from foo to bar/)
       end
     end
   end
 
-  describe '#export_clone' do
-    context 'when exclude_schedule is true' do
-      let(:options) { { exclude_schedules: true } }
-      let(:clone) { GoodData::Project.create(title: 'project clone', client: @client, auth_token: ConnectionHelper::GD_PROJECT_TOKEN) }
-
-      after do
-        clone.delete if clone
-      end
-
-      it 'excludes scheduled emails' do
-        @project.schedule_mail.save
-        export_token = @project.export_clone(options)
-        clone.import_clone(export_token)
-        expect(@project.scheduled_mails.to_a).not_to be_empty
-        expect(clone.scheduled_mails.to_a).to be_empty
-      end
+  describe '#blueprint' do
+    let(:project_data) do
+      {
+        'project' => {
+          'links' => { 'self' => '/gdc/foo' },
+          'meta' => { 'title' => 'My Project' }
+        }
+      }
     end
-
-    context 'when cross_data_center_export is true' do
-      it 'is ok' do
-        # there are no staging environments on other datacenters
-        # so just checking if the parameter gets accepted
-        @project.export_clone(cross_data_center_export: true)
-      end
+    let(:diff_result) do
+      { 'asyncTask' => { 'link' => { 'poll' => 'poll_me' } } }
     end
-
-    context 'when export task fails' do
-      let(:fail_response) do
-        response = { taskState: { status: 'ERROR' } }
-        GoodData::Helpers.stringify_keys(response)
-      end
-
-      before do
-        allow(@client)
-          .to receive(:poll_on_response).and_return(fail_response)
-      end
-
-      it 'raises ExportCloneError' do
-        expect { @project.export_clone }.to raise_error(GoodData::ExportCloneError)
-      end
+    let(:blueprint) { double(GoodData::Model::ProjectBlueprint) }
+    subject { GoodData::Project.new(project_data) }
+    before do
+      allow(client).to receive(:get).and_return(diff_result)
+      allow(client).to receive(:poll_on_code)
+      allow(GoodData::Model::FromWire).to receive(:from_wire) .and_return(blueprint)
+      allow(blueprint).to receive(:title=)
+      subject.client = client
     end
-  end
 
-  describe '#import_clone' do
-    let(:clone) { GoodData::Project.create(title: 'import clone test', client: @client, auth_token: ConnectionHelper::GD_PROJECT_TOKEN) }
-    let(:fail_response) do
-      response = { taskState: { status: 'ERROR' } }
-      GoodData::Helpers.stringify_keys(response)
+    context 'when include_ca option is true' do
+      it_behaves_like 'a blueprint provider'
     end
 
-    after do
-      clone.delete if clone
+    context 'when include_ca option is not specified' do
+      it_behaves_like 'a blueprint provider'
     end
 
-    context 'when import task fails' do
-      it 'raises ImportCloneError' do
-        export_token = @project.export_clone
-        allow(@client).to receive(:poll_on_response).and_return(fail_response)
-        expect { clone.import_clone(export_token) }.to raise_error(GoodData::ImportCloneError)
+    context 'when include_ca option is false' do
+      it 'requests model view with includeCA=false' do
+        expect(client).to receive(:get).with(
+          '/gdc/projects/foo/model/view',
+          hash_including(params: hash_including(includeCA: false))
+        )
+        subject.blueprint(include_ca: false)
       end
     end
   end