gooddata 1.0.0-java

data/spec/unit/actions/provision_clients_spec.rb

@@ -0,0 +1,45 @@
+# 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/actions/provision_clients'
+require 'gooddata/lcm/actions/purge_clients'
+require 'gooddata/lcm/lcm2'
+
+describe GoodData::LCM2::ProvisionClients do
+  let(:gdc_gd_client) { double('gdc_gd_client') }
+  let(:domain) { double('domain') }
+  let(:logger) { double('logger') }
+  let(:segment) { double('segment') }
+  let(:data_product) { double('data_product') }
+
+  before do
+    allow(gdc_gd_client).to receive(:domain).and_return(domain)
+    allow(logger).to receive(:debug)
+    allow(logger).to receive(:error).and_return({})
+    allow(segment).to receive(:segment_id).and_return({})
+    allow(segment).to receive(:provision_client_projects).and_raise('limit reached')
+    allow(domain).to receive(:segments) { segment }
+  end
+
+  context 'when provisioning get errors' do
+    let(:params) do
+      params = {
+        gdc_gd_client: gdc_gd_client,
+        gdc_logger: logger,
+        segments: [
+          segment
+        ],
+        data_product: data_product
+      }
+      GoodData::LCM2.convert_to_smart_hash(params)
+    end
+
+    it 'clean all zombie clients ' do
+      expect(GoodData::LCM2::PurgeClients).to receive(:call).and_return(results: [], params: { client_projects: [] })
+      expect { subject.class.call(params) }.to raise_error('limit reached')
+    end
+  end
+end

data/spec/unit/actions/purge_clients_spec.rb

@@ -0,0 +1,47 @@
+# 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/purge_clients'
+
+describe GoodData::LCM2::PurgeClients do
+  let(:client1) { double('client1') }
+  let(:client2) { double('client2') }
+  let(:project) { double('project') }
+
+  context "some clients which don't have project or project is deleted are existing in segment" do
+    let(:params) do
+      params = {
+        client_projects: {
+          'client_id' => {
+            segment_client: client1,
+            project: project
+          },
+          'delete' => {
+            segment_client: client2
+          }
+        }
+      }
+      GoodData::LCM2.convert_to_smart_hash(params)
+    end
+
+    before do
+      allow(client1).to receive(:project) { project }
+      allow(client1).to receive(:client_id) { 'client_id' }
+      allow(client2).to receive(:client_id) { 'delete' }
+      allow(client1).to receive(:delete)
+      allow(client2).to receive(:delete)
+      allow(project).to receive(:pid) { '123456789' }
+      allow(project).to receive(:deleted?) { false }
+    end
+
+    it 'purge them' do
+      expect(client2).to receive(:delete)
+      result = subject.class.call(params)[:results]
+      expect(result).to eq [{ client_id: 'client_id', project: '123456789', status: 'ok - not purged' }, { client_id: 'delete', project: nil, status: 'purged' }]
+    end
+  end
+end

data/spec/unit/actions/rename_existing_client_projects_spec.rb

@@ -0,0 +1,54 @@
+# 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::RenameExistingClientProjects do
+  let(:gdc_gd_client) { double('gdc_gd_client') }
+  let(:domain) { double('domain') }
+  let(:client) { double('client') }
+  let(:project) { double('project') }
+
+  context 'client project is existing in input source' do
+    let(:params) do
+      params = {
+        gdc_gd_client: gdc_gd_client,
+        organization: domain,
+        clients: [
+          {
+            id: 'Id',
+            settings: [
+              {
+                name: 'lcm.title',
+                value: 'renamed project'
+              }
+            ]
+          }
+        ],
+        client_projects: {
+          'Id' => { segment_client: client, project: project }
+        }
+      }
+      GoodData::LCM2.convert_to_smart_hash(params)
+    end
+
+    before do
+      allow(gdc_gd_client).to receive(:domain) { domain }
+      allow(client).to receive(:project) { project }
+      allow(project).to receive(:pid) { '123456789' }
+      allow(project).to receive(:title) { "old project" }
+      allow(project).to receive(:title=)
+      allow(project).to receive(:save)
+    end
+
+    it 'rename client project title' do
+      expect(project).to receive(:title=).with('renamed project')
+      result = subject.class.call(params)
+      expect(result).to eq [{ id: 'Id', pid: '123456789', old_title: 'old project', new_title: 'renamed project' }]
+    end
+  end
+end

data/spec/unit/actions/segments_filter_spec.rb

@@ -0,0 +1,46 @@
+# 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/actions/segments_filter'
+require 'gooddata/lcm/lcm2'
+
+describe GoodData::LCM2::SegmentsFilter do
+  context 'when segments contains duplicate segment ids' do
+    let(:params) do
+      params = {
+        segments: [
+          { segment_id: 'segment_foo' },
+          { segment_id: 'Segment_foo' }
+        ]
+      }
+      GoodData::LCM2.convert_to_smart_hash(params)
+    end
+
+    it 'raise error' do
+      expect { subject.class.call(params) }.to raise_error(/segment_foo/, /Segment_foo/)
+    end
+  end
+
+  context 'when passed segments' do
+    let(:params) do
+      params = {
+        segments: [
+          { segment_id: 'correct-segment' },
+          { segment_id: 'wrong-segment' }
+        ],
+        segments_filter: [
+          'correct-segment'
+        ]
+      }
+      GoodData::LCM2.convert_to_smart_hash(params)
+    end
+
+    it 'filters the segments according to segments_filter' do
+      results = subject.class.call(params)
+      expect(results[:results].first.segment_id).to eq 'correct-segment'
+    end
+  end
+end

data/spec/unit/actions/shared_examples_for_user_actions.rb

@@ -0,0 +1,26 @@
+shared_examples 'a user action reading client_id' 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
+
+shared_examples 'a user action filtering segments' do
+  let(:organization_not_in_segment) { double('organization') }
+  let(:project_not_in_segment) { double('project') }
+
+  before do
+    allow(organization_not_in_segment).to receive(:segment_uri).and_return('another-segment-uri')
+    allow(organization_not_in_segment).to receive(:project).and_return(project_not_in_segment)
+  end
+
+  it 'does operation on project only from clients in segments in segments filter' do
+    expect(project).to receive(message_for_project)
+    expect(project_not_in_segment).not_to receive(message_for_project)
+    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

@@ -0,0 +1,212 @@
+# 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(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