gooddata 1.1.0 → 1.2.0

data/spec/unit/actions/synchronize_clients_spec.rb

@@ -1,71 +0,0 @@
-# encoding: UTF-8
-#
-# Copyright (c) 2010-2018 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.
-
-describe GoodData::LCM2::SynchronizeClients do
-  subject { GoodData::LCM2::SynchronizeClients }
-  let(:failure_details) { '/link/to/details' }
-  let(:failed_count) { 42 }
-  let(:sync_failed_response_body) do
-    {
-      "synchronizationResult" => {
-        "successfulClients" => {
-          "count" => 0
-        },
-        "failedClients" => {
-          "count" => failed_count
-        },
-        "links" => {
-          "details" => failure_details
-        }
-      }
-    }
-  end
-
-  let(:sync_failed_response) { double(RestClient::Response) }
-  let(:gdc_gd_client) { double(GoodData::Rest::Client) }
-  let(:logger) { double(Logger) }
-  let(:organization_name) { 'big-boss-group' }
-  let(:organization) { double(GoodData::Domain) }
-  let(:segment) { double(GoodData::Segment) }
-  let(:ads_client) { double(GoodData::DataWarehouse) }
-  let(:params) do
-    params = {
-      gdc_gd_client: gdc_gd_client,
-      development_client: gdc_gd_client,
-      organization: organization_name,
-      segments: [segment],
-      release_table_name: 'LCM_RELEASE',
-      ads_client: ads_client,
-      gdc_logger: logger
-    }
-    GoodData::LCM2.convert_to_smart_hash(params)
-  end
-
-  before do
-    allow(gdc_gd_client).to receive(:domain).with(organization_name)
-                                            .and_return(organization)
-    allow(organization).to receive(:segments).and_return([segment])
-    allow(segment).to receive(:segment_id).and_return('id_of_my_segment')
-    allow(gdc_gd_client).to receive(:projects)
-    allow(ads_client).to receive(:execute_select).and_return([{}])
-    allow(segment).to receive(:master_project=)
-    allow(segment).to receive(:save)
-    allow(sync_failed_response)
-      .to receive(:json).and_return(sync_failed_response_body)
-  end
-
-  context 'when synchronizing client fails' do
-    before do
-      allow(segment)
-        .to receive(:synchronize_clients).and_return(sync_failed_response)
-    end
-    it 'fails with a clear error message' do
-      expected_error_message = "#{failed_count} clients failed to " \
-                               "synchronize. Details: #{failure_details}"
-      expect { subject.call(params) }.to raise_error(expected_error_message)
-    end
-  end
-end

data/spec/unit/actions/synchronize_etls_in_segment_spec.rb

@@ -1,206 +0,0 @@
-# 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_etls_in_segment'
-
-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
-      {
-        syncedResult: {
-          errors: [
-            {
-              errorId: "91a811a7-8d3a-42d2-a1ba-024933f74021",
-              errorCode: "gdc.lcm.schedule.fatal_error",
-              message: "Error",
-              parameters: []
-            }
-          ]
-        }
-      }
-    end
-
-    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(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
-
-    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('HELLO' => 'hi')
-        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('HELLO' => 'hi')
-        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('HELLO' => 'hi')
-        subject.class.call(params)
-      end
-    end
-  end
-end

data/spec/unit/actions/synchronize_ldm_spec.rb

@@ -1,70 +0,0 @@
-# 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(:target_project) { double(GoodData::Project) }
-  let(:synchronize) do
-    [{ from: 'from_pid', to: [{ pid: 'to_pid' }] }]
-  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)
-      .with('from_pid')
-      .and_return(project)
-    allow(gdc_gd_client).to receive(:projects)
-      .with('to_pid')
-      .and_return(target_project)
-    allow(project).to receive(:title)
-    allow(project).to receive(:pid)
-    allow(project).to receive(:blueprint)
-    allow(logger).to receive(:info)
-    allow(target_project).to receive(:title)
-    allow(target_project).to receive(:update_from_blueprint)
-  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
-
-  context 'when exclude_fact_rule is true' do
-    let(:params) { basic_params.merge(exclude_fact_rule: 'true') }
-    it 'calls update_from_blueprint with exclude_fact_rule option' do
-      expect(target_project).to receive(:update_from_blueprint)
-        .with(any_args, hash_including(exclude_fact_rule: true))
-      subject.class.call(converted_params)
-    end
-  end
-end

data/spec/unit/actions/synchronize_user_filters_spec.rb

@@ -1,208 +0,0 @@
-require 'active_support/core_ext/hash'
-require 'gooddata/lcm/lcm2'
-
-require_relative 'shared_examples_for_user_actions'
-
-shared_context 'using mode with custom_id' do
-  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
-end
-
-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 reading client_id' 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
-
-        it_behaves_like 'a user action filtering segments' do
-          let(:message_for_project) { :add_data_permissions }
-        end
-
-        context 'when dry_run param is true' do
-          let(:params) do
-            params = {
-              GDC_GD_CLIENT: client,
-              input_source: 'foo',
-              domain: 'bar',
-              filters_config: { labels: [] },
-              sync_mode: mode,
-              gdc_logger: logger,
-              dry_run: true
-            }
-            GoodData::LCM2.convert_to_smart_hash(params)
-          end
-
-          it 'sets the dry_run option' do
-            expect(project).to receive(:add_data_permissions)
-              .with(instance_of(Array), hash_including(dry_run: true))
-            subject.class.call(params)
-          end
-        end
-      end
-    end
-  end
-
-  context 'when using sync_one_project_based_on_custom_id mode with multiple_projects_column' do
-    include_context 'using mode with custom_id'
-    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
-
-    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
-
-  context 'when using sync_multiple_projects_based_on_custom_id mode' do
-    include_context 'using mode with custom_id'
-    let(:params) do
-      params = {
-        input_source: 'foo',
-        domain: 'bar',
-        multiple_projects_column: 'id_column',
-        sync_mode: 'sync_multiple_projects_based_on_custom_id',
-        gdc_logger: logger,
-        GDC_GD_CLIENT: client,
-        filters_config: { labels: [] }
-      }
-      GoodData::LCM2.convert_to_smart_hash(params)
-    end
-    it 'fails if the MUF set is empty' do
-      expect(File).to receive(:open)
-      expect(CSV).to receive(:foreach)
-      expect { subject.class.call(params) }.to raise_error(/The filter set can not be empty/)
-    end
-  end
-  context 'when using unsuported sync_mode' do
-    let(:params) do
-      params = {
-        filters_config: { labels: [] },
-        GDC_GD_CLIENT: client,
-        input_source: 'foo',
-        domain: 'bar',
-        multiple_projects_column: 'id_column',
-        sync_mode: 'unsuported_sync_mode', # sync_one_project_based_on_custom_id
-        gdc_logger: logger
-      }
-      GoodData::LCM2.convert_to_smart_hash(params)
-    end
-
-    it_should_behave_like 'when using unsuported sync_mode'
-  end
-end