gooddata 1.0.0-java

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,146 @@
+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 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
+      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

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,134 @@
+require 'active_support/core_ext/hash'
+require 'gooddata/lcm/lcm2'
+require_relative 'shared_examples_for_user_actions'
+
+shared_examples_for 'a user synchronizer' do
+  it 'does not fail and logs a warning' do
+    expect(logger).to receive(:warn).with(/not match any client ids/)
+    expect { subject.class.call(params) }.to_not raise_error
+  end
+end
+
+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') }
+  let(:project_uri) { '/gdc/projects/123abc' }
+
+  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(organization).to receive(:project_uri).and_return(project_uri)
+    allow(project).to receive(:import_users).and_return([{}])
+    allow(project).to receive(:metadata).and_return({})
+    allow(project).to receive(:uri).and_return(project_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 is sync_one_project_based_on_custom_id' do
+      let(:client_id) { '123456789' }
+
+      before do
+        allow(domain).to receive(:clients).and_return([organization])
+        allow(organization).to receive(:id).and_return(client_id)
+      end
+
+      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
+
+      context 'when the input set is empty' do
+        before do
+          allow(File).to receive(:open).and_return("")
+        end
+
+        it_behaves_like 'a user synchronizer'
+      end
+
+      context 'when the input set does not contain data for the current project' do
+        before do
+          allow(File).to receive(:open).and_return("client_id\ndifferent_from_123")
+        end
+
+        it_behaves_like 'a user synchronizer'
+      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")
+        allow(domain).to receive(:clients).and_return(organization)
+      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
+
+    context 'when using mode sync_domain_client_workspaces' do
+      let(:segment) { double('segment') }
+      let(:segment_uri) { 'segment_uri' }
+      let(:params) do
+        params = {
+          GDC_GD_CLIENT: client,
+          input_source: 'foo',
+          domain: 'bar',
+          gdc_logger: logger,
+          sync_mode: 'sync_domain_client_workspaces',
+          segments: [segment]
+        }
+        GoodData::LCM2.convert_to_smart_hash(params)
+      end
+
+      before do
+        allow(File).to receive(:open).and_return("client_id\n123456789")
+        allow(domain).to receive(:clients).with(:all, nil).and_return([organization, organization_not_in_segment])
+        allow(domain).to receive(:clients).with('123456789', nil).and_return(organization)
+        allow(segment).to receive(:uri).and_return(segment_uri)
+        allow(organization).to receive(:segment_uri).and_return(segment_uri)
+        allow(organization).to receive(:project).and_return(project)
+        allow(organization).to receive(:client_id).and_return('123456789')
+        allow(project).to receive(:deleted?).and_return(false)
+      end
+
+      it_behaves_like 'a user action filtering segments' do
+        let(:message_for_project) { :import_users }
+      end
+    end
+  end
+end

data/spec/unit/bricks/bricks_spec.rb

@@ -0,0 +1,34 @@
+# 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/bricks/bricks'
+
+describe GoodData::Bricks::Brick do
+  it "Has GoodData::Bricks::Brick class" do
+    GoodData::Bricks::Brick.should_not be(nil)
+  end
+
+  describe '#version' do
+    it 'Throws NotImplemented on base class' do
+      brick = GoodData::Bricks::Brick.new
+      expect do
+        brick.version
+      end.to raise_error(NotImplementedError)
+    end
+  end
+
+  it "should be possible to execute custom brick" do
+    class CustomBrick < GoodData::Bricks::Brick
+      def call(_params)
+        puts 'hello'
+      end
+    end
+
+    p = GoodData::Bricks::Pipeline.prepare([CustomBrick])
+
+    p.call({})
+  end
+end

data/spec/unit/bricks/middleware/aws_middelware_spec.rb

@@ -0,0 +1,98 @@
+# 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/bricks/brick'
+require 'gooddata/bricks/bricks'
+require 'gooddata/bricks/middleware/aws_middleware'
+
+describe GoodData::Bricks::AWSMiddleware do
+  subject { GoodData::Bricks::AWSMiddleware.new(app: proc {}) }
+
+  it 'should do nothing if the key "aws_client" is not there at all' do
+    middleware = GoodData::Bricks::AWSMiddleware.new(app: ->(_params) { 'Doing nothing' })
+    middleware.call({})
+  end
+
+  it 'should fail gracefully if value aws_client param not present even though the key is' do
+    middleware = GoodData::Bricks::AWSMiddleware.new(app: -> { 'Doing nothing' })
+    expect do
+      middleware.call('aws_client' => nil)
+    end.to raise_exception 'Unable to connect to AWS. Parameter "aws_client" seems to be empty'
+  end
+
+  it 'should fail gracefully if value secret_access_key is missing' do
+    middleware = GoodData::Bricks::AWSMiddleware.new(app: -> { 'Doing nothing' })
+    expect do
+      middleware.call('aws_client' => { 'access_key_id' => 'something' })
+    end.to raise_exception 'Unable to connect to AWS. Parameter "secret_access_key" is missing'
+  end
+
+  it 'should fail gracefully if value access_key_id is missing' do
+    middleware = GoodData::Bricks::AWSMiddleware.new(app: -> { 'Doing nothing' })
+    expect do
+      middleware.call('aws_client' => { 'secret_access_key' => 'something' })
+    end.to raise_exception 'Unable to connect to AWS. Parameter "access_key_id" is missing'
+  end
+
+  it "should preapre aws middleware for aws_client param" do
+    middleware = GoodData::Bricks::AWSMiddleware.new(app: lambda do |params|
+      expect(params['aws_client']['s3_client']).to be_kind_of(Aws::S3::Resource)
+    end)
+    middleware.call('aws_client' => { 'secret_access_key' => 'something', 'access_key_id' => 'something' })
+  end
+
+  context 'when use_ssl parameter specified' do
+    let(:params) do
+      {
+        'aws_client' => {
+          'access_key_id' => 'foo',
+          'secret_access_key' => 'bar',
+          'region' => 'baz',
+          'use_ssl' => 'false'
+        }
+      }
+    end
+
+    it 'raises an error' do
+      expect { subject.call(params) }.to raise_error(/use_ssl has been deprecated/)
+    end
+  end
+
+  context 'when a superfluous parameter is specified' do
+    let(:params) do
+      {
+        'aws_client' => {
+          'access_key_id' => 'foo',
+          'secret_access_key' => 'bar',
+          'region' => 'baz',
+          'qux' => 'quux'
+        }
+      }
+    end
+
+    it 'raises an error' do
+      expect { subject.call(params) }.to raise_error(ArgumentError, /qux/)
+    end
+  end
+
+  context 'when region not specified' do
+    let(:params) do
+      {
+        'aws_client' => {
+          'access_key_id' => 'foo',
+          'secret_access_key' => 'bar'
+        }
+      }
+    end
+
+    it 'it defaults to us-west-2' do
+      expect(Aws::S3::Resource).to receive(:new) do |params|
+        expect(params[:region]).to eq 'us-west-2'
+      end
+      subject.call(params)
+    end
+  end
+end