gooddata 1.0.0 → 1.0.1

data/spec/helpers/appstore_project_helper.rb

@@ -0,0 +1,221 @@
+# 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.
+
+
+# this is a duplicate of the appstore project helper - we should delete it when we merge repositories
+
+require 'gooddata'
+require 'json'
+require_relative 'constants'
+
+module GoodData
+  module Helpers
+    # Creates a testing project and loads it with data
+    class AppstoreProjectHelper
+      attr_reader :project, :client
+
+      class << self
+        def create(opts = { client: GoodData.connection })
+          new_project = opts[:client].create_project(opts)
+          AppstoreProjectHelper.new(new_project, opts)
+        end
+
+        def suffix
+          hostname = Socket.gethostname
+          timestamp = DateTime.now.strftime('%Y%m%d%H%M%S')
+          suffix = "#{hostname}_#{timestamp}"
+          segment_name_forbidden_chars = /[^a-zA-Z0-9_\\-]+/
+          suffix.scan(segment_name_forbidden_chars).each do |forbidden_characters|
+            suffix.gsub!(forbidden_characters, '_')
+          end
+          suffix
+        end
+      end
+
+      def initialize(project, opts = { client: GoodData.connection })
+        @client = opts[:client]
+        @project = project if project.instance_of? GoodData::Project
+        @project = client.projects(project) if project.instance_of? String
+        GoodData.logger.info "Project ID: #{@project.obj_id}"
+        raise 'ProjectHelper::initialize the parameter "project" '\
+            'must be GoodData::Project or String.' unless @project
+      end
+
+      def create_ldm
+        json = File.read('./spec/data/integration_model.json')
+        blueprint = GoodData::Model::ProjectBlueprint.from_json(json)
+        project.update_from_blueprint(blueprint)
+      end
+
+      def load_data
+        GoodData.with_project @project.pid do |project|
+          GoodData::Model.upload_data(
+            './spec/data/integration_policies.csv',
+            project.blueprint,
+            DATASET_IDENTIFIER
+          )
+        end
+      end
+
+      def add_user_group
+        @project.add_user_group(:name => USER_GROUP_NAME, :description => 'My Test Description')
+      end
+
+      def associate_output_stage(ads, opts = {})
+        @project.create_output_stage(
+          ads,
+          project: @project,
+          client: client,
+          client_id: opts[:client_id],
+          output_stage_prefix: opts[:output_stage_prefix]
+        )
+      end
+
+      def deploy_processes(ads)
+        GoodData.with_project @project.pid do |project|
+          cc_process = project.deploy_process(
+            CC_PROCESS_ARCHIVE,
+            name: CC_PROCESS_NAME
+          )
+          cc_schedule = cc_process.create_schedule(
+            CC_SCHEDULE_CRON,
+            CC_GRAPH,
+            params: CC_PARAMS,
+            hidden_params: CC_SECURE_PARAMS,
+            state: 'DISABLED'
+          )
+          ruby_process = project.deploy_process(
+            RUBY_HELLO_WORLD_PROCESS_PATH,
+            name: RUBY_HELLO_WORLD_PROCESS_NAME
+          )
+          ruby_schedule = ruby_process.create_schedule(
+            cc_schedule,
+            'main.rb',
+            params: RUBY_PARAMS,
+            hidden_params: RUBY_SECURE_PARAMS,
+            state: 'DISABLED'
+          )
+
+          associate_output_stage ads
+          add_process = project.add.process
+          add_process.create_schedule(
+            ruby_schedule,
+            '',
+            dataload_datasets: [ DATASET_IDENTIFIER ],
+            de_synchronize_all: true,
+            state: 'DISABLED'
+          )
+        end
+      end
+
+      def create_metrics
+        GoodData.with_project @project.pid do |project|
+          metrics = JSON.parse(File.read(METRICS_FILE)).to_hash
+          metrics.each do |title, maql|
+            metric = project.add_measure maql, title: title
+            metric.identifier = "metric.#{title.to_s.downcase.gsub(/\s/, '.')}"
+            metric.add_tag('metric') if metric.identifier == PRODUCTION_TAGGED_METRIC
+            metric.save
+          end
+        end
+      end
+
+      def create_computed_attributes
+        update = GoodData::Model::ProjectBlueprint.build('update') do |project_builder|
+          project_builder.add_computed_attribute(
+            COMPUTED_ATTRIBUTE_ID,
+            title: 'My computed attribute',
+            metric: 'metric.customers.count',
+            attribute: 'attr.csv_policies.state',
+            buckets: [{ label: 'Small', highest_value: 1000 }, { label: 'Medium', highest_value: 2000 }, { label: 'Large' }]
+          )
+        end
+        new_blueprint = project.blueprint.merge(update)
+        unless new_blueprint.valid?
+          pp new_blueprint.validate
+          raise 'Cannot create computed attribute'
+        end
+        project.update_from_blueprint(new_blueprint)
+
+        project.attributes(COMPUTED_ATTRIBUTE_ID).drill_down(project.attributes('attr.csv_policies.customer'))
+      end
+
+      def create_reports
+        GoodData.with_project @project.pid do |p|
+          reports = JSON.parse(File.read(REPORTS_FILE)).to_hash['reports']
+          reports.each do |r|
+            report = p.add_report(
+              title: r['title'],
+              left: r['left'].map { |o| GoodData::MdObject[o] },
+              top: r['top'].map { |o| GoodData::MdObject[o] }
+            )
+            report_name = r['title'].to_s.downcase.gsub(/\s/, '.')
+            report.identifier = "report.#{report_name}"
+            report.save
+          end
+
+          ca_report_title = 'Report contains CA'
+          report = p.add_report(title: ca_report_title, left: GoodData::MdObject[COMPUTED_ATTRIBUTE_ID])
+          report_name = ca_report_title.downcase.gsub(/\s/, '.')
+          report.identifier = "report.#{report_name}"
+          report.save
+        end
+      end
+
+      def create_dashboards
+        GoodData.with_project @project.pid do
+          dashboards = JSON.parse(File.read(DASHBOARDS_FILE)).to_hash['dashboards']
+          dashboards.each do |d|
+            dashboard = GoodData::Dashboard.create(
+              { title: d['title'] },
+              client: client, project: @project
+            )
+            d['tabs'].each do |t|
+              tab = dashboard.add_tab(title: t['title'])
+              t['items'].each do |i|
+                tab.add_report_item(report: GoodData::Report[i['identifier']],
+                                    position_x: i['position']['x'],
+                                    position_y: i['position']['y'],
+                                    size_x: i['size']['width'],
+                                    size_y: i['size']['height'])
+              end
+
+              tab.add_report_item(report: GoodData::Report['report.report.contains.ca'],
+                                  position_x: 0,
+                                  position_y: 0,
+                                  size_x: 640,
+                                  size_y:100)
+            end
+            dashboard_name = d['title'].to_s.downcase.gsub(/\s/, '.')
+            dashboard.identifier = "dashboard.#{dashboard_name}"
+            dashboard.add_tag('dashboard')
+            dashboard.save
+          end
+        end
+      end
+
+      def create_tag_for_fact_n_dataset
+        dataset = @project.datasets(DATASET_IDENTIFIER)
+        dataset.add_tag('dataset')
+        dataset.save
+
+        fact = @project.facts(FACT_IDENTIFIER)
+        fact.add_tag('fact')
+        fact.save
+      end
+
+      def ensure_user(login, domain)
+        user = domain.users(login)
+        unless user
+          user = domain.add_user(login: login)
+        end
+        @project.add_user(user, 'Viewer', domain: domain)
+        user
+      end
+    end
+  end
+end
+

data/spec/helpers/constants.rb

@@ -0,0 +1,32 @@
+module GoodData
+  module Helpers
+    BLUEPRINT_FILE = './spec/integration/data/model.json'
+    METRICS_FILE = './spec/integration/data/metrics.json'
+    REPORTS_FILE = './spec/integration/data/reports.json'
+    DASHBOARDS_FILE = './spec/integration/data/dashboards.json'
+
+    DATASET_IDENTIFIER = 'dataset.csv_policies'
+    FACT_IDENTIFIER = 'fact.csv_policies.customer_lifetime_value'
+    DATA_FILE = './spec/integration/data/policies.csv'
+
+    CC_PROCESS_ARCHIVE = './spec/integration/data/cc_process.zip'
+    CC_PROCESS_NAME = 'Simple CloudConnect Process'
+    CC_SCHEDULE_CRON = '0 15 10 3 *'
+    CC_GRAPH = 'graph/test.grf'
+    CC_PARAMS = { param_1: 'a', param_2: 'b' }
+    CC_SECURE_PARAMS = { secure_param_1: 'secretive_foo', secure_param_2: 'secretive_bar' }
+
+    RUBY_HELLO_WORLD_PROCESS_PATH = '${PUBLIC_APPSTORE}:branch/master:/apps/hello_world_brick'
+    RUBY_HELLO_WORLD_PROCESS_NAME = 'Simple Ruby Process'
+    RUBY_PARAMS = { param_1: 'a', param_2: 'b' }
+    RUBY_SECURE_PARAMS = { secure_param_1: 'secretive_baz', secure_param_2: 'secretive_qux' }
+
+    PRODUCTION_TAGGED_METRIC = 'metric.total.claim.amount'
+
+    CUSTOM_CLIENT_ID_COLUMN = 'custom_client_id_column'
+
+    COMPUTED_ATTRIBUTE_ID = 'attr.comp.my_computed_attr'
+
+    USER_GROUP_NAME = 'My Test Group'
+  end
+end

data/spec/integration/date_dim_switch_spec.rb

@@ -110,6 +110,10 @@ describe "Swapping a date dimension and exchanging all attributes/elements", :co
     expect(as.pmapcat { |a| a.usedby('metric') }).to be_empty
     expect(as.pmapcat { |a| a.usedby('dashboard') }).to be_empty
 
+    year_obj_id = @project.attributes
+                          .find { |a| a.identifier == 'created_on_2.year' }
+                          .obj_id
+
     # replace values
     mapping = GoodData::Helpers.prepare_mapping(suggest_mapping('created_on', 'created_on_2', @project), project: @project)
     @project.replace_from_mapping(mapping)
@@ -135,10 +139,10 @@ describe "Swapping a date dimension and exchanging all attributes/elements", :co
     expect(@report.definition.attributes.map(&:identifier)).to eq ["created_on_2.quarter"]
 
     ids = GoodData::SmallGoodZilla.get_uris(@report.definition.filters.first).map { |x| x.split('/')[-2..-1].join('/') }
-    expect(ids).to eq ["obj/281", "281/elements?id=2015", "281/elements?id=2016"]
+    expect(ids).to eq ["obj/#{year_obj_id}", "#{year_obj_id}/elements?id=2015", "#{year_obj_id}/elements?id=2016"]
 
     ids = GoodData::SmallGoodZilla.get_uris(@variable.values.first.expression).map { |v| v.split('/')[-2..-1].join('/') }
-    expect(ids).to eq ["obj/281", "281/elements?id=2015", "281/elements?id=2016"]
+    expect(ids).to eq ["obj/#{year_obj_id}", "#{year_obj_id}/elements?id=2015", "#{year_obj_id}/elements?id=2016"]
 
     # Swap the dims
     bp = @project.blueprint

data/spec/integration/models/label_spec.rb

@@ -0,0 +1,40 @@
+# 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'
+
+describe GoodData::Label do
+  before(:all) do
+    @rest_client = ConnectionHelper.create_default_connection
+    @suffix = AppstoreProjectHelper.suffix
+    @opts = {
+      client: @rest_client,
+      title: "Project for label spec #{@suffix}",
+      auth_token: ConnectionHelper::GD_PROJECT_TOKEN,
+      environment: 'TESTING',
+      prod_organization: 'staging-lcm-prod'
+    }
+    project_helper = AppstoreProjectHelper.create(@opts)
+    project_helper.create_ldm
+    project_helper.load_data
+    @project = project_helper.project
+    @label = @project.attributes('label.csv_policies.customer')
+  end
+  after(:all) do
+    @project.delete unless @project.deleted?
+  end
+  # this is a substring of another value in the set, AA10041
+  let(:expected_id) { 'AA1004' }
+
+  describe '#get_valid_elements' do
+    it 'returns an exact match' do
+      eles = @label.get_valid_elements filter: expected_id
+      eles['validElements']['items'].each do |ele|
+        expect(ele['element']['title']).to eq expected_id
+      end
+    end
+  end
+end

data/spec/unit/actions/synchronize_clients_spec.rb

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