gooddata 1.0.2-java → 1.1.0-java

data/spec/spec_helper.rb

@@ -3,6 +3,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.
+#
+ENV['RSPEC_ENV'] = 'test'
 
 require 'simplecov'
 # for simplecov to work correctly, it has to be started before any other code
@@ -26,12 +28,13 @@ require 'pathname'
 require 'webmock/rspec'
 require 'gooddata'
 
+vcr_enabled = !ENV['VCR_ON'] || ENV['VCR_ON'] == 'true' # VCR is enabled by default - set VCR_ON=false to disable
+require 'vcr_configurer' if vcr_enabled
+
 logger = Logger.new(STDOUT)
 logger.level = Logger::WARN
 GoodData.logger = logger
 
-WebMock.disable!
-
 # Automagically include all helpers/*_helper.rb
 
 require_relative 'environment/environment'
@@ -63,4 +66,45 @@ RSpec.configure do |config|
   config.filter_run_excluding :broken => true
 
   config.fail_fast = false
+
+  if vcr_enabled
+    config.before(:all) do
+      # in case the test uses VCR
+      if self.class.metadata[:vcr]
+        # replace parallel iterations with the serial one, since VCR can't handle parallel request matching correctly
+        module Enumerable
+          def peach_with_index(*)
+            each_with_index
+          end
+        end
+
+        # insert the cassete recording everything what happens outside the tests cases
+        VCR.insert_cassette("#{self.class.metadata[:description]}/all")
+
+        # avoid polling idle time by overriding sleep
+        module Kernel
+          alias :old_sleep :sleep
+          def sleep(n)
+            n
+          end
+        end
+      end
+    end
+
+    config.after(:all) do
+      # in case the test uses VCR
+      if self.class.metadata[:vcr]
+        # eject the cassete recording everything what happens outside the tests cases
+        VCR.eject_cassette
+
+        # reload the original parallel iterations
+        load('pmap.rb') if self.class.metadata[:vcr]
+
+        # reload sleep method
+        module Kernel
+          alias :sleep :old_sleep
+        end
+      end
+    end
+  end
 end

data/spec/unit/actions/associate_clients_spec.rb

@@ -34,7 +34,8 @@ describe GoodData::LCM2::AssociateClients do
         gdc_gd_client: gdc_gd_client,
         clients: [
           { segment: segment }
-        ]
+        ],
+        domain: domain
       }
       GoodData::LCM2.convert_to_smart_hash(params)
     end

data/spec/unit/actions/collect_data_product_spec.rb

@@ -24,6 +24,7 @@ describe GoodData::LCM2::CollectDataProduct do
     let(:data_product_id) { 'data-product' }
     let(:params) do
       params = {
+        domain: domain,
         gdc_gd_client: client,
         gdc_logger: gdc_logger,
         data_product: data_product_id
@@ -42,7 +43,8 @@ describe GoodData::LCM2::CollectDataProduct do
     let(:params) do
       params = {
         gdc_gd_client: client,
-        gdc_logger: gdc_logger
+        gdc_logger: gdc_logger,
+        domain: domain
       }
       GoodData::LCM2.convert_to_smart_hash(params)
     end

data/spec/unit/actions/collect_segment_clients_spec.rb

@@ -57,6 +57,7 @@ describe GoodData::LCM2::CollectSegmentClients do
         gdc_gd_client: gdc_gd_client,
         synchronize: [{}],
         segments: [segment],
+        domain: domain,
         ads_client: ads_client
       }
       GoodData::LCM2.convert_to_smart_hash(params)

data/spec/unit/actions/create_segment_masters_spec.rb

@@ -26,6 +26,7 @@ describe GoodData::LCM2::CreateSegmentMasters do
         segments: [{ segment_id: 'segment_foo', driver: 'Pg', master_name: 'name' }],
         tokens: { pg: 'pgtoken' },
         ads_client: ads_client,
+        domain: domain,
         development_client: development_client,
         gdc_logger: gdc_logger,
         project_environment: 'DEVELOPMENT',

data/spec/unit/actions/ensure_data_product_spec.rb

@@ -18,6 +18,7 @@ describe GoodData::LCM2::EnsureDataProduct do
       params = {
         data_product: "data-product-#{SecureRandom.uuid}",
         gdc_gd_client: client,
+        domain: domain,
         gdc_logger: gdc_logger
       }
       GoodData::LCM2.convert_to_smart_hash(params)

data/spec/unit/actions/ensure_technical_users_domain_spec.rb

@@ -31,6 +31,7 @@ describe GoodData::LCM2::EnsureTechnicalUsersDomain do
     let(:params) do
       params = {
         gdc_gd_client: gdc_gd_client,
+        domain: domain,
         technical_user: ['foo@bar.com']
       }
       GoodData::LCM2.convert_to_smart_hash(params)
@@ -42,6 +43,7 @@ describe GoodData::LCM2::EnsureTechnicalUsersDomain do
     let(:params) do
       params = {
         gdc_gd_client: gdc_gd_client,
+        domain: domain,
         technical_users: ['foo@bar.com']
       }
       GoodData::LCM2.convert_to_smart_hash(params)

data/spec/unit/actions/ensure_technical_users_project_spec.rb

@@ -25,6 +25,7 @@ end
 describe GoodData::LCM2::EnsureTechnicalUsersProject do
   let(:gdc_gd_client) { double(:gdc_gd_client) }
   let(:project) { double(:project) }
+  let(:domain) { double(:domain) }
   before do
     allow(project).to receive(:title) { 'foo project' }
     allow(project).to receive(:pid) { 'abcdefg' }
@@ -38,6 +39,7 @@ describe GoodData::LCM2::EnsureTechnicalUsersProject do
         gdc_gd_client: gdc_gd_client,
         technical_users: ['foo@bar.com'],
         synchronize: [],
+        domain: domain,
         clients: [{ project: 'abcdefg' }]
       }
       GoodData::LCM2.convert_to_smart_hash(params)
@@ -51,6 +53,7 @@ describe GoodData::LCM2::EnsureTechnicalUsersProject do
       params = {
         gdc_gd_client: gdc_gd_client,
         technical_user: ['foo@bar.com'],
+        domain: domain,
         synchronize: [{ to: [{ pid: 'qux' }] }]
       }
       GoodData::LCM2.convert_to_smart_hash(params)
@@ -62,6 +65,7 @@ describe GoodData::LCM2::EnsureTechnicalUsersProject do
     let(:params) do
       params = {
         gdc_gd_client: gdc_gd_client,
+        domain: domain,
         technical_users: ['foo@bar.com'],
         synchronize: [{ to: [{ pid: 'qux' }] }]
       }

data/spec/unit/actions/provision_clients_spec.rb

@@ -32,12 +32,13 @@ describe GoodData::LCM2::ProvisionClients do
         segments: [
           segment
         ],
+        domain: domain,
         data_product: data_product
       }
       GoodData::LCM2.convert_to_smart_hash(params)
     end
 
-    it 'clean all zombie clients ' do
+    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

data/spec/unit/actions/synchronize_etls_in_segment_spec.rb

@@ -125,9 +125,7 @@ describe GoodData::LCM2::SynchronizeETLsInSegment do
       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
@@ -161,9 +159,7 @@ describe GoodData::LCM2::SynchronizeETLsInSegment do
       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
@@ -202,9 +198,7 @@ describe GoodData::LCM2::SynchronizeETLsInSegment do
       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

data/spec/unit/actions/synchronize_ldm_spec.rb

@@ -15,8 +15,9 @@ 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: 'foo', to: [] }]
+    [{ from: 'from_pid', to: [{ pid: 'to_pid' }] }]
   end
   let(:basic_params) do
     {
@@ -31,15 +32,18 @@ describe GoodData::LCM2::SynchronizeLdm do
   end
 
   before do
-    allow(gdc_gd_client).to receive(:projects).and_return(project)
+    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)
-  end
-
-  context 'when include_computed_attributes is not specified' do
-    let(:params) { basic_params }
-    it_behaves_like 'a computed attributes synchronizer'
+    allow(target_project).to receive(:title)
+    allow(target_project).to receive(:update_from_blueprint)
   end
 
   context 'when include_computed_attributes is true' do
@@ -54,4 +58,13 @@ describe GoodData::LCM2::SynchronizeLdm do
       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

@@ -85,6 +85,27 @@ describe GoodData::LCM2::SynchronizeUserFilters do
         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

data/spec/unit/helpers/check_helper_production_spec.rb

@@ -0,0 +1,34 @@
+require 'gooddata/lcm/actions/base_action'
+require 'gooddata/lcm/helpers/check_helper'
+require 'gooddata/lcm/types/types'
+
+describe 'GoodData::LCM2::Helpers::Check' do
+  let(:params) do
+    params = { test_param_three: 'Testing param three' }
+    GoodData::LCM2.convert_to_smart_hash(params)
+  end
+  let(:spec) do
+    GoodData::LCM2::BaseAction.define_params(self) do
+      description 'Testing param two'
+      param :test_param_two, instance_of(GoodData::LCM2::Type::StringType), required: true
+
+      description 'Testing param four'
+      param :test_param_three, instance_of(GoodData::LCM2::Type::IntegerType), required: false
+    end
+  end
+  context 'when running outside the tests' do
+    let(:mocked_logger) { double(Logger) }
+    before do
+      expect(GoodData).to receive(:logger).and_return(mocked_logger)
+      expect(ENV).to receive(:[]).with('RSPEC_ENV').and_return('production')
+      expect(mocked_logger).to receive(:error)
+    end
+    it 'writes out error message but do not fail when virifying required params' do
+      expect { GoodData::LCM2::Helpers.check_params(spec, params) }.not_to raise_error(/Mandatory/)
+    end
+
+    it 'writes out error message but do not fail when checking types' do
+      expect { GoodData::LCM2::Helpers.check_params(spec, params) }.not_to raise_error(/has invalid type/)
+    end
+  end
+end

data/spec/unit/helpers/check_helper_spec.rb

@@ -7,21 +7,27 @@ require 'gooddata/lcm/actions/base_action'
 require 'gooddata/lcm/helpers/check_helper'
 require 'gooddata/lcm/types/types'
 
-describe 'GoodData::LCM2::Helpers::Checkout' do
+describe 'GoodData::LCM2::Helpers::Check' do
   let(:params) do
     params = {
       test_param_two: 'Testing param two',
       test_param_three: 'Testing param three',
-      test_param_four: 4
+      test_param_four: 4,
+      UPPER_case_param: 'qux'
     }
     GoodData::LCM2.convert_to_smart_hash(params)
   end
-  it 'verifies required' do
-    PARAMS = GoodData::LCM2::BaseAction.define_params(self) do
+  let(:spec) do
+    GoodData::LCM2::BaseAction.define_params(self) do
       description 'Testing param one'
       param :test_param_one, instance_of(GoodData::LCM2::Type::StringType), required: true
+
+      description 'Param four'
+      param :test_param_four, instance_of(GoodData::LCM2::Type::StringType), required: false
     end
-    expect { GoodData::LCM2::Helpers.check_params(PARAMS, params) }.to raise_error(/Mandatory/)
+  end
+  it 'verifies required' do
+    expect { GoodData::LCM2::Helpers.check_params(spec, params) }.to raise_error(/Mandatory/)
   end
 
   it 'fills default' do
@@ -37,10 +43,92 @@ describe 'GoodData::LCM2::Helpers::Checkout' do
   end
 
   it 'checks types' do
-    PARAMS_3 = GoodData::LCM2::BaseAction.define_params(self) do
-      description 'Testing param four'
-      param :test_param_four, instance_of(GoodData::LCM2::Type::StringType), required: false
+    params['test_param_one'] = 'test_param_one'
+    expect { GoodData::LCM2::Helpers.check_params(spec, params) }.to raise_error(/has invalid type/)
+  end
+
+  it 'fails when unspecified variable is acessed' do
+    params.setup_filters(spec)
+    expect { params[:test_param_three] }.to raise_error(/not defined in the specification/)
+  end
+
+  context 'when created from stringified hash' do
+    subject { GoodData::LCM2::Helpers.check_params(spec, params) }
+    let(:params) do
+      raw_params = { 'update_preference' => { 'keep_data' => false,
+                                              'allow_cascade_drops' => true } }
+      GoodData::LCM2.convert_to_smart_hash(raw_params)
+    end
+
+    let(:spec) do
+      GoodData::LCM2::BaseAction.define_params(self) do
+        description 'Some param'
+        param :update_preference, instance_of(GoodData::LCM2::Type::UpdatePreferenceType), required: false
+
+        description 'Replacement param'
+        param :replacement_param, instance_of(GoodData::LCM2::Type::GdClientType), required: false
+
+        description 'Deprecated param'
+        param :deprecated_param, instance_of(GoodData::LCM2::Type::StringType), required: false, deprecated: true, replacement: :replacement_param
+
+        description 'List of production tag Names'
+        param :production_tags, array_of(instance_of(GoodData::LCM2::Type::StringType)), required: false
+
+        description 'Production Tag Names'
+        param :production_tag, instance_of(GoodData::LCM2::Type::StringType), required: false, deprecated: true, replacement: :production_tags
+
+        description 'Default testing param'
+        param :default_test, array_of(instance_of(GoodData::LCM2::Type::StringType)), required: false, default: 'default value'
+
+        description 'Deprecated testing param'
+        param :deprecated_test, instance_of(GoodData::LCM2::Type::StringType), required: false, deprecated: true, replacement: :default_test
+      end
+    end
+
+    it 'works with default values' do
+      subject
+      expect(params[:update_preference][:keep_data]).to be(false)
+    end
+
+    context 'when deprecated params together with default values are supplied' do
+      let(:params) do
+        raw_params = {
+          'deprecated_param' => 'franta',
+          'production_tag' => 'pepa',
+          'update_preference' => {
+            'cascade_drops' => true,
+            'keep_data' => false
+          },
+          'deprecated_test' => 'jednicka'
+        }
+        GoodData::LCM2.convert_to_smart_hash(raw_params)
+      end
+      it 'works with default values on deprecated params' do
+        subject
+        expect(params[:update_preference][:keep_data]).to be(false)
+        expect(params[:update_preference][:cascade_drops]).to be(true)
+      end
+
+      it 'does not fill default values on replacement params if deprecated one has value' do
+        subject
+        expect(params[:default_test]).to be(nil)
+        expect(params[:deprecated_test]).to eq('jednicka')
+      end
+    end
+  end
+
+  context 'when key contains upper-case letters' do
+    let(:spec) do
+      GoodData::LCM2::BaseAction.define_params(self) do
+        description 'Testing param'
+        param :upper_case_param, instance_of(GoodData::LCM2::Type::StringType)
+      end
+    end
+
+    before { params.setup_filters(spec) }
+
+    it 'fetching works with both lower case and original case' do
+      ['upper_case_param', :upper_case_param, 'UPPER_case_param', :UPPER_case_param].map { |e| expect(params[e]).to eq('qux') }
     end
-    expect { GoodData::LCM2::Helpers.check_params(PARAMS_3, params) }.to raise_error(/has invalid type/)
   end
 end