gooddata 0.6.53 → 0.6.54

data/spec/unit/actions/shared_examples_for_user_actions.rb

@@ -0,0 +1,10 @@
+shared_examples 'a user action' do
+  before do
+    allow(File).to receive(:open).and_return("client_id\n#{client_id}")
+  end
+
+  it 'uses client_id column' do
+    expect(domain).to receive(:clients).with(client_id, nil)
+    subject.class.call(params)
+  end
+end

data/spec/unit/actions/synchronize_cas_spec.rb

@@ -0,0 +1,58 @@
+# 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.
+
+shared_examples 'a computed attributes synchronizer' do
+  it 'it synchronizes computed attributes' do
+    expect(project).to receive(:execute_maql).with('expected_maql')
+    result = subject.class.call(converted_params)
+    expect(result).not_to be_empty
+  end
+end
+
+describe GoodData::LCM2::SynchronizeComputedAttributes do
+  let(:gdc_gd_client) { double(GoodData::Rest::Client) }
+  let(:logger) { double(Logger) }
+  let(:project) { double(GoodData::Project) }
+  let(:synchronize) do
+    [{ from: 'foo', to: [{ ca_scripts: { 'maqlDdlChunks' => ['expected_maql'] } }] }]
+  end
+  let(:basic_params) do
+    {
+      gdc_gd_client: gdc_gd_client,
+      development_client: gdc_gd_client,
+      synchronize: synchronize,
+      gdc_logger: logger
+    }
+  end
+  let(:converted_params) do
+    GoodData::LCM2.convert_to_smart_hash(params)
+  end
+
+  before do
+    allow(gdc_gd_client).to receive(:projects).and_return(project)
+    allow(project).to receive(:title)
+    allow(project).to receive(:pid)
+    allow(logger).to receive(:info)
+  end
+
+  context 'when include_computed_attributes is not specified' do
+    let(:params) { basic_params }
+    it_behaves_like 'a computed attributes synchronizer'
+  end
+
+  context 'when include_computed_attributes is true' do
+    let(:params) { basic_params.merge(include_computed_attributes: 'true') }
+    it_behaves_like 'a computed attributes synchronizer'
+  end
+
+  context 'when include_computed_attributes is false' do
+    let(:params) { basic_params.merge(include_computed_attributes: 'false') }
+    it 'it does not synchronize computed attributes' do
+      result = subject.class.call(converted_params)
+      expect(result).to be_empty
+    end
+  end
+end

data/spec/unit/actions/synchronize_etls_in_segment_spec.rb

@@ -11,6 +11,38 @@ describe GoodData::LCM2::SynchronizeETLsInSegment do
   let(:gdc_gd_client) { double('gdc_gd_client') }
   let(:domain) { double('domain') }
   let(:segment) { double('segment') }
+  let(:project) { double('project') }
+  let(:result) { { syncedResult: {} } }
+  let(:client_id) { 'foo_client' }
+  let(:data_product) { double('data_product') }
+  let(:params) do
+    params = {
+      gdc_gd_client: gdc_gd_client,
+      organization: domain,
+      synchronize: [{
+        segment_id: 'some_segment_ids',
+        to: [{ pid: 'foo', client_id: client_id }]
+      }],
+      data_product: data_product
+    }
+    GoodData::LCM2.convert_to_smart_hash(params)
+  end
+
+  before do
+    allow(gdc_gd_client).to receive(:domain) { domain }
+    allow(gdc_gd_client).to receive(:projects) { project }
+    allow(project).to receive(:schedules) { [] }
+    allow(data_product).to receive(:segments) { [segment] }
+    allow(segment).to receive(:synchronize_processes) { result }
+    allow(project).to receive(:set_metadata)
+    allow(segment).to receive(:segment_id) { 'some_segment_ids' }
+  end
+
+  it 'adds GOODOT_CUSTOM_PROJECT_ID to metadata' do
+    expect(project).to receive(:set_metadata)
+      .with('GOODOT_CUSTOM_PROJECT_ID', client_id)
+    subject.class.call(params)
+  end
 
   context 'when sync processes/schedules has problem' do
     let(:result) do
@@ -28,24 +60,153 @@ describe GoodData::LCM2::SynchronizeETLsInSegment do
       }
     end
 
-    let(:params) do
-      params = {
-        gdc_gd_client: gdc_gd_client,
-        organization: domain,
-        synchronize: [{ segment_id: 'some_segment_ids' }]
-
-      }
-      GoodData::LCM2.convert_to_smart_hash(params)
+    it 'raise error' do
+      expect { subject.class.call(params) }.to raise_error
     end
+  end
+
+  context 'when user passes dynamic schedule parameters' do
+    let(:project) { double(:project) }
+    let(:schedule1) { double(:schedule1) }
+    let(:schedule2) { double(:schedule2) }
 
     before do
-      allow(gdc_gd_client).to receive(:domain) { domain }
-      allow(domain).to receive(:segments) { segment }
-      allow(segment).to receive(:synchronize_processes) { result }
+      allow(segment).to receive(:synchronize_processes).and_return(
+        syncedResult: {
+          clients: [
+            client: {
+              id: 'foo',
+              project: 'bar'
+            }
+          ]
+        }
+      )
+      allow(segment).to receive(:master_project_id)
+      allow(schedule1).to receive(:update_hidden_params)
+      allow(schedule1).to receive(:enable)
+      allow(schedule1).to receive(:save)
+      allow(schedule1).to receive(:name) { 'Schedule1' }
+      allow(schedule2).to receive(:update_hidden_params)
+      allow(schedule2).to receive(:enable)
+      allow(schedule2).to receive(:save)
+      allow(schedule2).to receive(:name) { 'Schedule2' }
+      allow(project).to receive(:schedules) { [schedule1, schedule2] }
+      allow(gdc_gd_client).to receive(:projects) { project }
     end
 
-    it 'raise error' do
-      expect { subject.class.call(params) }.to raise_error
+    context 'to each schedules' do
+      let(:params) do
+        params = {
+          gdc_gd_client: gdc_gd_client,
+          organization: domain,
+          synchronize: [
+            {
+              segment_id: 'some_segment_ids',
+              from: 'from project',
+              to: [
+                pid: '123',
+                client_id: 'foo'
+              ]
+            }
+          ],
+          schedule_params: {
+            all_clients: {
+              'Schedule1' => {
+                'HELLO' => 'hi'
+              },
+              'Schedule2' => {
+                'BYE' => 'bye'
+              }
+            }
+          },
+          data_product: data_product
+        }
+        GoodData::LCM2.convert_to_smart_hash(params)
+      end
+
+      it 'each schedules must have different parameters' do
+        schedule1.should_receive(:update_params).once.ordered.with(CLIENT_ID: 'foo', GOODOT_CUSTOM_PROJECT_ID: 'foo')
+        schedule1.should_receive(:update_params).once.ordered.with('HELLO' => 'hi')
+        schedule2.should_receive(:update_params).once.ordered.with(CLIENT_ID: 'foo', GOODOT_CUSTOM_PROJECT_ID: 'foo')
+        schedule2.should_receive(:update_params).once.ordered.with('BYE' => 'bye')
+        subject.class.call(params)
+      end
+    end
+
+    context 'to all schedules' do
+      let(:params) do
+        params = {
+          gdc_gd_client: gdc_gd_client,
+          organization: domain,
+          synchronize: [
+            {
+              segment_id: 'some_segment_ids',
+              from: 'from project',
+              to: [
+                pid: '123',
+                client_id: 'foo'
+              ]
+            }
+          ],
+          schedule_params: {
+            all_clients: {
+              all_schedules: {
+                'HELLO' => 'hi'
+              }
+            }
+          },
+          data_product: data_product
+        }
+        GoodData::LCM2.convert_to_smart_hash(params)
+      end
+
+      it 'all schedules must have the parameter' do
+        schedule1.should_receive(:update_params).once.ordered.with(CLIENT_ID: 'foo', GOODOT_CUSTOM_PROJECT_ID: 'foo')
+        schedule1.should_receive(:update_params).once.ordered.with('HELLO' => 'hi')
+        schedule2.should_receive(:update_params).once.ordered.with(CLIENT_ID: 'foo', GOODOT_CUSTOM_PROJECT_ID: 'foo')
+        schedule2.should_receive(:update_params).once.ordered.with('HELLO' => 'hi')
+        subject.class.call(params)
+      end
+    end
+
+    context 'to each schedules in each clients' do
+      let(:params) do
+        params = {
+          gdc_gd_client: gdc_gd_client,
+          organization: domain,
+          synchronize: [
+            {
+              segment_id: 'some_segment_ids',
+              from: 'from project',
+              to: [
+                pid: '123',
+                client_id: 'foo'
+              ]
+            }
+          ],
+          schedule_params: {
+            'foo' => {
+              'Schedule1' => {
+                'HELLO' => 'hi'
+              }
+            },
+            'bar' => {
+              'Schedule2' => {
+                'BYE' => 'bye'
+              }
+            }
+          },
+          data_product: data_product
+        }
+        GoodData::LCM2.convert_to_smart_hash(params)
+      end
+
+      it 'parameters should be passed to the correct client project and schedule' do
+        schedule1.should_receive(:update_params).once.ordered.with(CLIENT_ID: 'foo', GOODOT_CUSTOM_PROJECT_ID: 'foo')
+        schedule1.should_receive(:update_params).once.ordered.with('HELLO' => 'hi')
+        schedule2.should_receive(:update_params).once.ordered.with(CLIENT_ID: 'foo', GOODOT_CUSTOM_PROJECT_ID: 'foo')
+        subject.class.call(params)
+      end
     end
   end
 end

data/spec/unit/actions/synchronize_ldm_spec.rb

@@ -0,0 +1,57 @@
+# 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.
+
+shared_examples 'a computed attributes synchronizer' do
+  it 'diffs LDM with computed attributes' do
+    expect(project).to receive(:blueprint).with(include_ca: true)
+    subject.class.call(converted_params)
+  end
+end
+
+describe GoodData::LCM2::SynchronizeLdm do
+  let(:gdc_gd_client) { double(GoodData::Rest::Client) }
+  let(:logger) { double(Logger) }
+  let(:project) { double(GoodData::Project) }
+  let(:synchronize) do
+    [{ from: 'foo', to: [] }]
+  end
+  let(:basic_params) do
+    {
+      gdc_gd_client: gdc_gd_client,
+      development_client: gdc_gd_client,
+      synchronize: synchronize,
+      gdc_logger: logger
+    }
+  end
+  let(:converted_params) do
+    GoodData::LCM2.convert_to_smart_hash(params)
+  end
+
+  before do
+    allow(gdc_gd_client).to receive(:projects).and_return(project)
+    allow(project).to receive(:title)
+    allow(project).to receive(:pid)
+    allow(logger).to receive(:info)
+  end
+
+  context 'when include_computed_attributes is not specified' do
+    let(:params) { basic_params }
+    it_behaves_like 'a computed attributes synchronizer'
+  end
+
+  context 'when include_computed_attributes is true' do
+    let(:params) { basic_params.merge(include_computed_attributes: 'true') }
+    it_behaves_like 'a computed attributes synchronizer'
+  end
+
+  context 'when include_computed_attributes is false' do
+    let(:params) { basic_params.merge(include_computed_attributes: 'false') }
+    it 'diffs LDM without computed attributes' do
+      expect(project).to receive(:blueprint).with(include_ca: false)
+      subject.class.call(converted_params)
+    end
+  end
+end

data/spec/unit/actions/synchronize_user_filters_spec.rb

@@ -0,0 +1,142 @@
+require 'active_support/core_ext/hash'
+require 'gooddata/lcm/lcm2'
+
+require_relative 'shared_examples_for_user_actions'
+
+describe GoodData::LCM2::SynchronizeUserFilters 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(:domain).and_return(domain)
+    allow(organization).to receive(:project_uri)
+    allow(project).to receive(:add_data_permissions).and_return([{}])
+    allow(project).to receive(:pid).and_return('123456789')
+    allow(user).to receive(:login).and_return('my_login')
+    allow(GoodData::Helpers::DataSource).to receive(:new).and_return(data_source)
+    allow(logger).to receive(:warn)
+  end
+
+  context 'when multiple_projects_column not specified' do
+    before do
+      allow(project).to receive(:metadata).and_return({})
+      allow(project).to receive(:uri)
+      allow(data_source).to receive(:realize)
+      allow(organization).to receive(:id).and_return('client123')
+      allow(organization).to receive(:project).and_return(project)
+    end
+    context 'when mode requires client_id' do
+      before do
+        allow(domain).to receive(:clients).and_return(organization)
+      end
+      let(:mode) { 'sync_multiple_projects_based_on_custom_id' }
+      let(:params) do
+        params = {
+          GDC_GD_CLIENT: client,
+          input_source: 'foo',
+          domain: 'bar',
+          filters_config: { labels: [] },
+          sync_mode: mode,
+          gdc_logger: logger
+        }
+        GoodData::LCM2.convert_to_smart_hash(params)
+      end
+
+      it_behaves_like 'a user action' do
+        let(:client_id) { '123456789' }
+      end
+
+      context 'when mode is sync_domain_client_workspaces' do
+        let(:mode) { 'sync_domain_client_workspaces' }
+        let(:clients) { [] }
+        before do
+          allow(domain).to receive(:clients).with(:all, nil).and_return([organization])
+          allow(domain).to receive(:clients).with(123_456_789).and_return(organization)
+          allow(organization).to receive(:project).and_return(project)
+          allow(organization).to receive(:client_id).and_return(123_456_789)
+          allow(File).to receive(:open).and_return("client_id\n123456789")
+          allow(project).to receive(:deleted?).and_return false
+        end
+        it 'returns results' do
+          result = subject.class.call(params)
+          expect(result).to eq(results: [[{}]])
+        end
+      end
+    end
+  end
+
+  context 'when using sync_one_project_based_on_custom_id mode with multiple_projects_column' do
+    let(:params) do
+      params = {
+        GDC_GD_CLIENT: client,
+        input_source: 'foo',
+        domain: 'bar',
+        filters_config: { labels: [] },
+        multiple_projects_column: 'id_column',
+        sync_mode: 'sync_one_project_based_on_custom_id',
+        gdc_logger: logger
+      }
+      GoodData::LCM2.convert_to_smart_hash(params)
+    end
+    let(:CSV) { double('CSV') }
+
+    before do
+      allow(project).to receive(:metadata).and_return(
+        'GOODOT_CUSTOM_PROJECT_ID' => 'project-123'
+      )
+      allow(project).to receive(:uri).and_return('project-uri')
+      allow(project).to receive(:add_data_permissions)
+      allow(domain).to receive(:clients).and_return([])
+      allow(data_source).to receive(:realize).and_return('filepath')
+    end
+
+    context 'when params do not match client data in domain' do
+      before do
+        allow(project).to receive(:metadata).and_return({})
+        allow(project).to receive(:uri).and_return('project-uri')
+        allow(domain).to receive(:clients).and_return([])
+      end
+
+      it 'fails when unable to get filter value for selecting filters' do
+        expect { subject.class.call(params) }.to raise_exception(/does not contain key GOODOT_CUSTOM_PROJECT_ID/)
+      end
+    end
+
+    context 'when params match a client in the domain' do
+      it 'adds filters matching the client' do
+        expect(File).to receive(:open)
+        csv_data = [
+          {
+            'id_column' => 'project-123'
+          },
+          {
+            'id_column' => 'another-project'
+          }
+        ]
+        expect(CSV).to receive(:foreach).and_yield(csv_data[0]).and_yield(csv_data[1])
+        expect(GoodData::UserFilterBuilder).to receive(:get_filters) do |filters, _|
+          filters.each do |filter|
+            expect(filter['id_column']).to eq 'project-123'
+          end
+        end
+        subject.class.call(params)
+      end
+    end
+
+    context 'when the input set does not contain data for the current project' do
+      it 'does not fail and logs a warning' do
+        expect(File).to receive(:open)
+        expect(CSV).to receive(:foreach).and_yield({})
+        expect(project).to receive(:add_data_permissions)
+        expect(logger).to receive(:warn)
+        expect { subject.class.call(params) }.to_not raise_error
+      end
+    end
+  end
+end