gooddata 1.1.0 → 1.2.0

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

@@ -1,15 +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/bricks/brick'
-require 'gooddata/bricks/bricks'
-require 'gooddata/bricks/middleware/stdout_middleware'
-
-describe GoodData::Bricks::STDOUTLoggingMiddleware do
-  it "Has GoodData::Bricks::STDOUTLoggingMiddleware class" do
-    GoodData::Bricks::STDOUTLoggingMiddleware.should_not be(nil)
-  end
-end

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

@@ -1,15 +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/bricks/brick'
-require 'gooddata/bricks/bricks'
-require 'gooddata/bricks/middleware/twitter_middleware'
-
-describe GoodData::Bricks::TwitterMiddleware do
-  it "Has GoodData::Bricks::TwitterMiddleware class" do
-    GoodData::Bricks::TwitterMiddleware.should_not be(nil)
-  end
-end

data/spec/unit/cli/cli_spec.rb

@@ -1,17 +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/cli/cli'
-
-describe GoodData::CLI do
-  it 'Has GoodData::CLI class' do
-    expect(GoodData::CLI).not_to be_nil
-  end
-
-  it 'Has GoodData::CLI::main() working' do
-    run_cli
-  end
-end

data/spec/unit/cli/commands/cmd_auth_spec.rb

@@ -1,17 +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/cli/cli'
-
-describe 'GoodData::CLI - auth', :broken => true do
-  describe 'auth' do
-    it 'Can be called without arguments' do
-      args = %w(auth)
-
-      run_cli(args)
-    end
-  end
-end

data/spec/unit/core/nil_logger_spec.rb

@@ -1,13 +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/core/core'
-
-describe GoodData::NilLogger do
-  it "Has GoodData::NilLogger class" do
-    GoodData::NilLogger.should_not be(nil)
-  end
-end

data/spec/unit/extensions/hash_spec.rb

@@ -1,22 +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.
-
-describe Hash do
-  describe '#deep_dup' do
-    it 'should crete a deep copy' do
-      x = {
-        :a => {
-          :b => :c
-        }
-      }
-      y = x.dup
-      deep_y = GoodData::Helpers.deep_dup(x)
-
-      expect(y[:a].object_id).to be == x[:a].object_id
-      expect(deep_y[:a].object_id).not_to be == x[:a].object_id
-    end
-  end
-end

data/spec/unit/godzilla/goodzilla_spec.rb

@@ -1,74 +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'
-
-describe GoodData::SmallGoodZilla do
-  MAQL_EXAMPLE = 'SELECT SUM(#"Amount") WHERE @"Date"=#"X" AND ?"Snapshot EOP"=1'
-  FACTS = {
-    "Amount" => "a",
-    "X" => "x"
-  }
-  ATTRIBUTES = {
-    "Date" => "d"
-  }
-  METRICS = {
-    "Snapshot EOP" => "snap"
-  }
-  DICT = {
-    :facts => FACTS,
-    :attributes => ATTRIBUTES,
-    :metrics => METRICS
-  }
-
-  it "should parse metrics out of the string" do
-    expect(GoodData::SmallGoodZilla.get_facts(MAQL_EXAMPLE)).to eq %w(Amount X)
-  end
-
-  it "should parse attributes out of the string" do
-    expect(GoodData::SmallGoodZilla.get_attributes(MAQL_EXAMPLE)).to eq %w(Date)
-  end
-
-  it "should parse metrics out of the string" do
-    expect(GoodData::SmallGoodZilla.get_metrics(MAQL_EXAMPLE)).to eq ["Snapshot EOP"]
-  end
-
-  it "should interpolate the values" do
-    interpolated = GoodData::SmallGoodZilla.interpolate(
-      {
-        :facts => %w(Amount X),
-        :attributes => ["Date"],
-        :metrics => ["Snapshot EOP"]
-      },
-      DICT
-    )
-
-    expect(interpolated).to eq(
-      :facts => [%w(Amount a), %w(X x)],
-      :attributes => [%w(Date d)],
-      :metrics => [["Snapshot EOP", "snap"]]
-    )
-  end
-
-  it "should return interpolated metric" do
-    expect(GoodData::SmallGoodZilla.interpolate_metric(MAQL_EXAMPLE, DICT)).to eq "SELECT SUM([a]) WHERE [d]=[x] AND [snap]=1"
-  end
-
-  it "should be able to parse several ids correctly." do
-    metric = "SELECT SUM(
-        CASE
-          WHEN ![attr.customer_profiles.profile_id] = [/gdc/md/pxa3aic06undadkc5s7t5lxpne11vgyt/obj/257/elements?id=65] THEN ![fact.perfomance_by_campaign_id.general_score_1]
-          WHEN ![attr.customer_profiles.profile_id] = [/gdc/md/pxa3aic06undadkc5s7t5lxpne11vgyt/obj/257/elements?id=50] THEN ![fact.perfomance_by_campaign_id.general_score_5]
-          WHEN ![attr.customer_profiles.profile_id] = [/gdc/md/pxa3aic06undadkc5s7t5lxpne11vgyt/obj/257/elements?id=20]  THEN ![fact.perfomance_by_campaign_id.general_score_12]
-        END)"
-    expect(GoodData::SmallGoodZilla.get_ids(metric)).to eq [
-      "attr.customer_profiles.profile_id",
-      "fact.perfomance_by_campaign_id.general_score_1",
-      "fact.perfomance_by_campaign_id.general_score_5",
-      "fact.perfomance_by_campaign_id.general_score_12"
-    ]
-  end
-end

data/spec/unit/helpers/check_helper_production_spec.rb

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

@@ -1,134 +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/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_two: 'Testing param two',
-      test_param_three: 'Testing param three',
-      test_param_four: 4,
-      UPPER_case_param: 'qux'
-    }
-    GoodData::LCM2.convert_to_smart_hash(params)
-  end
-  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
-  end
-  it 'verifies required' do
-    expect { GoodData::LCM2::Helpers.check_params(spec, params) }.to raise_error(/Mandatory/)
-  end
-
-  it 'fills default' do
-    PARAMS_2 = GoodData::LCM2::BaseAction.define_params(self) do
-      description 'Testing param one'
-      param :test_param_one, instance_of(GoodData::LCM2::Type::StringType), required: true, default: 'filled_default_value'
-
-      description 'Testing param two'
-      param :test_param_two, instance_of(GoodData::LCM2::Type::StringType), required: false
-    end
-    GoodData::LCM2::Helpers.check_params(PARAMS_2, params)
-    expect(params[:test_param_one]).to match(/filled_default_value/)
-  end
-
-  it 'checks types' do
-    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
-  end
-end

data/spec/unit/helpers/csv_helper_spec.rb

@@ -1,22 +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/helpers/csv_helper'
-
-describe GoodData::Helpers::Csv do
-  describe '#read' do
-    it 'Reads data from CSV file' do
-      GoodData::Helpers::Csv.read(:path => CsvHelper::CSV_PATH_IMPORT)
-    end
-  end
-
-  describe '#write' do
-    it 'Writes data to CSV' do
-      data = []
-      GoodData::Helpers::Csv.write(:path => CsvHelper::CSV_PATH_EXPORT, :data => data)
-    end
-  end
-end

data/spec/unit/helpers/data_helper_spec.rb

@@ -1,67 +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/helpers/data_helper'
-
-describe GoodData::Helpers::DataSource do
-  let(:file_size) { 666 }
-
-  before :each do
-    @s3_client = double('s3_client')
-    @bucket = double('bucket')
-    @objects = double('objects')
-
-    allow(@s3_client).to receive(:bucket) { @bucket }
-    allow(@bucket).to receive(:object) { @objects }
-    allow(@objects).to receive(:get) { StringIO.new('aaa') }
-    allow(@objects).to receive(:size) { file_size }
-    allow(File).to receive(:size) { file_size }
-
-    @ds = GoodData::Helpers::DataSource.new(type: :s3, bucket: 'some_bucket', key: 'some_key')
-  end
-
-  it 'should be able to handle AWS' do
-    expect(@ds.realized?).to be_falsey
-    params = { 'aws_client' => { 's3_client' => @s3_client } }
-    expect(@ds.realize(params)).to eq '2bdc6c8a02b2bd1d7997cf17f0848ecfcbceba25ca184e2676f19c054db7139b'
-    expect(@ds.realized?).to be_truthy
-  end
-
-  it 'should gracefully handle missing aws client' do
-    expect do
-      @ds.realize('aws_client' => nil)
-    end.to raise_exception "AWS client not present. Perhaps S3Middleware is missing in the brick definition?"
-  end
-
-  it 'should gracefully handle missing data source params - bucket' do
-    ds = GoodData::Helpers::DataSource.new(type: :s3, key: 'some_key')
-    params = { 'aws_client' => { 's3_client' => @s3_client } }
-    expect do
-      ds.realize(params)
-    end.to raise_exception 'Key "bucket" is missing in S3 datasource'
-  end
-
-  it 'should gracefully handle missing data source params - key' do
-    ds = GoodData::Helpers::DataSource.new(type: :s3, bucket: 'some_bucket')
-    params = { 'aws_client' => { 's3_client' => @s3_client } }
-    expect do
-      ds.realize(params)
-    end.to raise_exception 'Key "key" is missing in S3 datasource'
-  end
-
-  context 'when size of the downloaded file is not right' do
-    before do
-      allow(File).to receive(:size) { 0 }
-    end
-
-    it 'raises an error' do
-      params = { 'aws_client' => { 's3_client' => @s3_client } }
-      expect do
-        @ds.realize(params)
-      end.to raise_exception(/Expected size 666, got 0/)
-    end
-  end
-end

data/spec/unit/helpers/global_helpers_spec.rb

@@ -1,264 +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/helpers/csv_helper'
-
-describe GoodData::Helpers do
-  describe '#diff' do
-    before :each do
-      @old_tomas = { id: 1, name: 'Tomas', age: 28 }
-      @new_tomas = { id: 1, name: "Lil'Tomas", age: 28 }
-      @patrick = { id: 4, name: 'Patrick', age: 24 }
-      @old_korczis = { id: 3, name: 'Korczis', age: 23 }
-      @new_korczis = { id: 3, name: "Korczis", age: 22 }
-      @petr = { id: 2, name: 'Petr', age: 32 }
-      @cvengy = { id: 5, name: 'Petr', age: 30 }
-
-      @old_list = [@cvengy, @old_tomas, @patrick, @old_korczis]
-      @new_list = [@cvengy, @new_tomas, @petr, @new_korczis]
-    end
-
-    it 'diffs two lists of hashes' do
-      diff = GoodData::Helpers.diff(@old_list, @new_list, key: :id)
-
-      expect(diff[:same]).to eq [@cvengy]
-      expect(diff[:added]).to eq [@petr]
-      expect(diff[:removed]).to eq [@patrick]
-      expect(diff[:changed]).to eq([
-        {
-          old_obj: @old_tomas,
-          new_obj: @new_tomas,
-          diff: { name: "Lil'Tomas" }
-        },
-        {
-          old_obj: @old_korczis,
-          new_obj: @new_korczis,
-          diff: { age: 22 }
-        }
-      ])
-    end
-
-    it 'diffs two lists of hashes on subset of fields' do
-      diff = GoodData::Helpers.diff(@old_list, @new_list, key: :id, fields: [:id, :age])
-
-      expect(diff[:same]).to eq [@cvengy, @old_tomas]
-      expect(diff[:added]).to eq [@petr]
-      expect(diff[:removed]).to eq [@patrick]
-      expect(diff[:changed]).to eq([
-        {
-          old_obj: @old_korczis,
-          new_obj: @new_korczis,
-          diff: { age: 22 }
-        }
-      ])
-    end
-
-    it 'should encode params and preserve the nil in hidden' do
-      x = GoodData::Helpers.decode_params("x" => "y", GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY.to_s => '{"a":{"b": "c"}}')
-      expect(x).to eq("x" => "y", "a" => { "b" => "c" }, "gd_encoded_hidden_params" => nil)
-    end
-
-    it 'should encode params and preserve the nil in hidden' do
-      x = GoodData::Helpers.decode_params(GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY.to_s => nil)
-      expect(x).to eq("gd_encoded_hidden_params" => nil)
-    end
-
-    it 'should encode params and preserve the nil in hidden' do
-      x = GoodData::Helpers.decode_params(
-        "x" => "y",
-        GoodData::Helpers::ENCODED_PARAMS_KEY.to_s => '{"d":{"b": "c"}}',
-        GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY.to_s => '{"a":{"b": "c"}}'
-      )
-      expect(x).to eq("x" => "y", "a" => { "b" => "c" }, "d" => { "b" => "c" }, "gd_encoded_hidden_params" => nil)
-    end
-
-    it 'should encode params and note preserve the nil in public' do
-      x = GoodData::Helpers.decode_params("x" => "y", GoodData::Helpers::ENCODED_PARAMS_KEY.to_s => '{"d":{"b": "c"}}')
-      expect(x).to eq("x" => "y", "d" => { "b" => "c" })
-    end
-
-    it 'should be abe to join datasets' do
-      master = [{ id: 'a', x: 1 },
-                { id: 'b', x: 1 },
-                { id: 'c', x: 2 }]
-
-      lookup = [{ id: 1, y: 'FOO' },
-                { id: 2, y: 'BAR' }]
-
-      results = GoodData::Helpers.join(master, lookup, [:x], [:id])
-      expect(results).to eq [{ :id => "a", :y => "FOO", :x => 1 },
-                             { :id => "b", :y => "FOO", :x => 1 },
-                             { :id => "c", :y => "BAR", :x => 2 }]
-    end
-
-    it 'should encode secure params' do
-      params = {
-        "x" => "y",
-        "d|b|foo" => "bar",
-        "d|b|e|w" => "z",
-        GoodData::Helpers::ENCODED_PARAMS_KEY.to_s => '{"d":{"b":{"c": "a"}}}',
-        GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY.to_s => '{"d":{"b":{"e":{"f": "g"}}}}'
-      }
-      x = GoodData::Helpers.decode_params(params, convert_pipe_delimited_params: true)
-      expect(x).to eq(
-        "x" => "y",
-        "d" => { "b" => { "c" => "a", "e" => { "f" => "g", "w" => "z" }, "foo" => "bar" } },
-        "gd_encoded_hidden_params" => nil
-      )
-    end
-
-    context 'when hidden parameters contain an invalid json' do
-      let(:invalid_json) { '{"password": "precious_secret"' }
-      let(:params) do
-        { GoodData::Helpers::ENCODED_HIDDEN_PARAMS_KEY.to_s => invalid_json }
-      end
-
-      it 'hides secrets in the error message' do
-        expect { GoodData::Helpers.decode_params(params) }.to raise_error(JSON::ParserError) do |e|
-          expect(e.message).not_to include('precious_secret')
-        end
-      end
-    end
-
-    it 'should not throw error if missing reference parameter placeholder' do
-      params = {
-        'x' => 'y',
-        'ads_password' => 'ads_123',
-        'gd_encoded_params' => '{"login_username": "login_user", "login_password": "${my_password}"}'
-      }
-      expected_result = {
-        'x' => 'y',
-        'ads_password' => 'ads_123',
-        'login_username' => 'login_user',
-        'login_password' => '${my_password}'
-      }
-      result = GoodData::Helpers.decode_params(params, :resolve_reference_params => true)
-      expect(result).to eq(expected_result)
-    end
-
-    it 'should encode reference parameters in gd_encoded_params' do
-      params = {
-        'x' => 'y',
-        'ads_password' => 'ads_123',
-        'my_password' => 'login_123',
-        'gd_encoded_params' => '{"login_username": "login_user", "login_password": "abc_${my_password}_123"}'
-      }
-      expected_result = {
-        'x' => 'y',
-        'ads_password' => 'ads_123',
-        'my_password' => 'login_123',
-        'login_username' => 'login_user',
-        'login_password' => 'abc_login_123_123'
-      }
-      result = GoodData::Helpers.decode_params(params, :resolve_reference_params => true)
-      expect(result).to eq(expected_result)
-    end
-
-    it 'should encode escape reference parameters in gd_encoded_params' do
-      params = {
-        'x' => 'y',
-        'ads_password' => 'ads_123',
-        'my_password' => 'login_123',
-        'gd_encoded_params' => '{"login_username": "login_user", "data01": "\\${abc}"}'
-      }
-      expected_result = {
-        'x' => 'y',
-        'ads_password' => 'ads_123',
-        'my_password' => 'login_123',
-        'login_username' => 'login_user',
-        'data01' => '${abc}'
-      }
-      result = GoodData::Helpers.decode_params(params, :resolve_reference_params => true)
-      expect(result).to eq(expected_result)
-    end
-
-    it 'should encode reference parameters in nested block in gd_encoded_params' do
-      params = {
-        'x' => 'y',
-        'ads_password' => 'ads_123',
-        'my_password' => 'login_123',
-        'gd_encoded_params' => '{"login_username": "login_user", "ads_client": {"username": "ads_user", "password": "${ads_password}"}}'
-      }
-      expected_result = {
-        'x' => 'y',
-        'ads_password' => 'ads_123',
-        'my_password' => 'login_123',
-        'login_username' => 'login_user',
-        'ads_client' => {
-          'username' => 'ads_user',
-          'password' => 'ads_123'
-        }
-      }
-      result = GoodData::Helpers.decode_params(params, :resolve_reference_params => true)
-      expect(result).to eq(expected_result)
-    end
-
-    it 'should convert all values into String' do
-      params = {
-        x: true,
-        y: ['hello', false],
-        z: {
-          z1: false,
-          z2: [true],
-          z3: [[[false]]]
-        }
-      }
-      expected_result = {
-        x: 'true',
-        y: %w(hello false),
-        z: {
-          z1: 'false',
-          z2: ['true'],
-          z3: [[['false']]]
-        }
-      }
-      result = GoodData::Helpers.stringify_values(params)
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe '.interpolate_error_message' do
-    let(:error_message) { { 'error' => { 'message' => 'foo %s', 'parameters' => ['bar'] } } }
-
-    before do
-      @message = GoodData::Helpers.interpolate_error_message(error_message)
-    end
-
-    it 'interpolates parameters' do
-      expect(@message).to eq('foo bar')
-    end
-
-    context 'when error parameter is empty' do
-      let(:error_message) { {} }
-      it 'returns nil' do
-        expect(@message).to be_nil
-      end
-    end
-
-    context 'when error key is empty' do
-      let(:error_message) { { 'error' => {} } }
-      it 'returns nil' do
-        expect(@message).to be_nil
-      end
-    end
-  end
-
-  describe '.decode_params' do
-    it 'interpolates reference parameters in additional_hidden_params' do
-      params = {
-        'gd_encoded_hidden_params' => '{ "additional_hidden_params": { "secret": "${my_password}" } }',
-        'my_password' => "123"
-      }
-      expected_result = {
-        'gd_encoded_hidden_params' => nil,
-        'additional_hidden_params' => { 'secret' => '123' },
-        'my_password' => '123'
-      }
-      result = GoodData::Helpers.decode_params(params, :resolve_reference_params => true)
-      expect(result).to eq(expected_result)
-    end
-  end
-end