gooddata 1.1.0-java → 1.2.0-java

data/spec/unit/models/user_filters/user_filter_builder_spec.rb

@@ -1,149 +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.
-
-shared_examples 'a user filter deleter' do
-  it 'deletes the filter' do
-    expect(existing_filter).to receive(:delete)
-    result = subject.execute_mufs(filter_definitions, options)
-    expect(result[:deleted].length).to be(1)
-  end
-end
-
-describe GoodData::UserFilterBuilder do
-  describe '.execute_mufs' do
-    let(:login) { 'rubydev+admin@gooddata.com' }
-    let(:full_definition_filter) do
-      {
-        :login => login,
-        :filters => [{
-          :label => label_id,
-          :over => nil,
-          :to => nil,
-          :values => ["Washington"]
-        }]
-      }
-    end
-
-    let(:label_id) { 'label.csv_policies.state' }
-    let(:label_uri) { '/gdc/md/wock3futg594lz3ornqv70yvbsivf896/obj/270' }
-    let(:filter_definitions) { [full_definition_filter] }
-    let(:options) do
-      { client: client, project: project }
-    end
-    let(:users_brick_input) { [{ 'login' => login }] }
-    let(:client) { double('client') }
-    let(:project) { double('project') }
-    let(:user) { double('user') }
-    let(:project_users) { [user] }
-    let(:label) { double('label') }
-    let(:filter) { double('filter') }
-    let(:existing_filter) { double('existing_filter') }
-    let(:profile_url) { '/gdc/account/profile/foo' }
-
-    before do
-      allow(project).to receive(:labels).with(label_uri)
-        .and_return(label)
-      allow(project).to receive(:labels).with("label.csv_policies.state")
-        .and_return(label)
-      allow(project).to receive(:attributes)
-      allow(project).to receive(:users).and_return(project_users)
-      allow(project).to receive(:data_permissions).and_return([existing_filter])
-      allow(project).to receive(:pid)
-      allow(label).to receive(:values_count).and_return(666_666)
-      allow(label).to receive(:uri).and_return(label_uri)
-      allow(label).to receive(:find_value_uri).with('Washington').and_return('foo')
-      allow(label).to receive(:attribute_uri).and_return('bar')
-      allow(label).to receive(:identifier).and_return(label_id)
-      allow(client).to receive(:create).and_return(filter)
-      allow(client).to receive(:get)
-        .and_return('userFilters' => { 'items' => [] })
-      allow(client).to receive(:post)
-        .and_return('userFiltersUpdateResult' => [])
-      allow(filter).to receive(:related_uri)
-      allow(existing_filter).to receive(:related_uri)
-      allow(filter).to receive(:save)
-      allow(filter).to receive(:uri)
-      allow(user).to receive(:login).and_return(login)
-      allow(user).to receive(:profile_url).and_return(login)
-    end
-
-    it 'resolves mufs to be created/deleted' do
-      expect(existing_filter).to_not receive(:delete)
-      result = subject.execute_mufs(filter_definitions, options)
-      expect(result[:created].length).to be(1)
-      expect(result[:deleted].length).to be(0)
-    end
-
-    context 'when dry_run option set to true' do
-      let(:options) do
-        { client: client,
-          project: project,
-          dry_run: true }
-      end
-
-      it 'does not alter filters' do
-        expect(client).not_to receive(:post)
-        subject.execute_mufs(filter_definitions, options)
-      end
-
-      it 'returns results' do
-        result = subject.execute_mufs(filter_definitions, options)
-        expected = [{ status: 'dry_run', user: nil, type: 'create' }]
-        expect(result[:results]).to eq(expected)
-      end
-    end
-
-    context 'when users_brick_input option specified' do
-      let(:user) { double('user') }
-      let(:users_brick_input) { [{ 'login' => login }] }
-      let(:options) do
-        { client: client,
-          project: project,
-          users_brick_input: users_brick_input }
-      end
-      before do
-        allow(project).to receive(:users).and_return([user])
-        allow(user).to receive(:login).and_return(login)
-        allow(user).to receive(:profile_url).and_return(profile_url)
-      end
-
-      context 'when filter has user in users_brick_input' do
-        before do
-          allow(existing_filter).to receive(:json)
-            .and_return(related: profile_url)
-        end
-        it_behaves_like 'a user filter deleter'
-        context 'when users_brick_input has symbols as keys' do
-          let(:users_brick_input) { [{ login: login }] }
-          it_behaves_like 'a user filter deleter'
-        end
-      end
-
-      context 'when filter does not have user in users_brick_input' do
-        before do
-          allow(existing_filter).to receive(:json)
-            .and_return(related: 'not_in_users_brick_input')
-        end
-
-        it 'does not delete filter' do
-          result = subject.execute_mufs(filter_definitions, options)
-          expect(result[:deleted]).to be_empty
-        end
-      end
-    end
-
-    context 'when creating MUFs results in errors' do
-      before do
-        allow(client).to receive(:post)
-          .and_return 'userFiltersUpdateResult' => { 'failed' => [{ status: :failed }] }
-      end
-
-      it 'fails' do
-        expect { subject.execute_mufs(filter_definitions, options) }.to raise_error(/Creating MUFs resulted in errors/)
-      end
-    end
-  end
-end

data/spec/unit/models/user_filters_spec.rb

@@ -1,95 +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'
-
-def check_filters(filters)
-  filters.count.should eq(2)
-  filter = filters.first
-  filter[:login].should eq("john.doe@example.com")
-  filter[:filters].count.should eq(1)
-  filter[:filters].first[:values].count.should eq(4)
-  filter[:filters].first[:values].should eq(["USA", "Czech Republic", "Uganda", "Slovakia"])
-  filter = filters.last
-  filter[:login].should eq("jane.doe@example.com")
-  filter[:filters].count.should eq(1)
-  filter[:filters].first[:values].count.should eq(1)
-end
-
-describe 'User filters implementation' do
-  it "should create user filters from a file using row based approach" do
-    filters = GoodData::UserFilterBuilder.get_filters(
-      './spec/data/line_based_permissions.csv',
-      :labels => [{ :label => "/gdc/md/lu292gm1077gtv7i383hjl149sva7o1e/obj/2719" }]
-    )
-    check_filters(filters)
-  end
-
-  it "should create user filters from a file using column based approach" do
-    filters = GoodData::UserFilterBuilder.get_filters(
-      './spec/data/column_based_permissions.csv',
-      :labels => [{ :label => "/gdc/md/lu292gm1077gtv7i383hjl149sva7o1e/obj/2719", :column => 'region' }]
-    )
-    check_filters(filters)
-  end
-
-  it "should treat empty like nil, empty value has to be enclosed in quotes" do
-    filters = GoodData::UserFilterBuilder.get_filters(
-      './spec/data/column_based_permissions.csv',
-      :labels => [
-        { :label => "some_label", :column => 'region' },
-        { :label => "other_label", :column => 'department' }
-      ]
-    )
-    filters.first[:filters].last[:values].count.should eq(3)
-  end
-
-  it "should be able to specify columns by number" do
-    filters = GoodData::UserFilterBuilder.get_filters(
-      './spec/data/column_based_permissions2.csv',
-      :user_column => 2,
-      :labels => [
-        { :label => "some_label", :column => 0 },
-        { :label => "other_label", :column => 1 }
-      ]
-    )
-    filters.first[:filters].last[:values].count.should eq(2)
-  end
-
-  it "should be able to specify columns by name" do
-    filters = GoodData::UserFilterBuilder.get_filters(
-      './spec/data/column_based_permissions2.csv',
-      :user_column => 'login',
-      :labels => [
-        { :label => 'some_label', :column => 'region' },
-        { :label => 'other_label', :column => 'department' }
-      ]
-    )
-    filters.first[:filters].last[:values].count.should eq(2)
-  end
-
-  it "should normalize simplified filters" do
-    filters = [
-      [
-        "svarovsky+gem_tester@gooddata.com",
-        "/gdc/md/zndbmx87kh69vk8liods10mwxesaxn3k/obj/213",
-        "tomas@gooddata.com",
-        "jirka@gooddata.com"
-      ]
-    ]
-    GoodData::UserFilterBuilder.normalize_filters(filters).should eq([
-      {
-        :login => "svarovsky+gem_tester@gooddata.com",
-        :filters => [
-          {
-            :label => "/gdc/md/zndbmx87kh69vk8liods10mwxesaxn3k/obj/213",
-            :values => ["tomas@gooddata.com", "jirka@gooddata.com"]
-          }
-        ]
-      }
-    ])
-  end
-end

data/spec/unit/models/variable_spec.rb

@@ -1,280 +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'
-
-ROW_BASED_DATA = [
-  ['tomas@gooddata.com', 'US', 'CZ', 'KZ'],
-  ['petr@gooddata.com', 'US'],
-  ['petr@gooddata.com', 'KZ']
-]
-COLUMN_BASED_DATA_WITH_HEADERS = [
-  {
-    :login => 'tomas@gooddata.com',
-    :country => 'US',
-    :age => 14
-  },
-  {
-    :login => 'petr@gooddata.com',
-    :country => 'US',
-    :age => 19
-  },
-  {
-    :login => 'petr@gooddata.com',
-    :country => 'KZ',
-    :age => 30
-  }
-]
-
-COLUMN_BASED_DATA_WITH_HEADERS_AND_NIL_VAL = [
-  {
-    :login => 'tomas@gooddata.com',
-    :country => 'US',
-    :age => 14
-  },
-  {
-    :login => 'petr@gooddata.com',
-    :country => 'US',
-    :age => 19
-  },
-  {
-    :login => 'petr@gooddata.com',
-    :country => 'KZ',
-    :age => nil
-  }
-]
-
-COLUMN_BASED_DATA_WITH_HEADERS_AND_EMPTY_VAL = [
-  {
-    :login => 'tomas@gooddata.com',
-    :country => 'US',
-    :age => 14
-  },
-  {
-    :login => 'petr@gooddata.com',
-    :country => 'US',
-    :age => 19
-  },
-  {
-    :login => 'petr@gooddata.com',
-    :country => 'KZ',
-    :age => ''
-  }
-]
-
-describe "DSL" do
-  it "should pick the values from row based file" do
-    results = GoodData::UserFilterBuilder.get_values(ROW_BASED_DATA, :labels => [{ :label => "label/34" }])
-    results.should == {
-      "tomas@gooddata.com" => [
-        { :label => "label/34", :values => %w(US CZ KZ), :over => nil, :to => nil }
-      ],
-     "petr@gooddata.com" => [
-       { :label => "label/34", :values => ["US"], :over => nil, :to => nil },
-       { :label => "label/34", :values => ["KZ"], :over => nil, :to => nil }
-      ]
-    }
-  end
-
-  it "should pick the values from column based file" do
-    results = GoodData::UserFilterBuilder.get_values(
-      COLUMN_BASED_DATA_WITH_HEADERS,
-      :type => :filter,
-      :user_column => :login,
-      :labels => [{ :label => "label/34", :column => :country }]
-    )
-    results.should == {
-      "tomas@gooddata.com" => [
-        { :label => "label/34", :values => ["US"], :over => nil, :to => nil }
-      ],
-     "petr@gooddata.com" => [
-       { :label => "label/34", :values => ["US"], :over => nil, :to => nil },
-       { :label => "label/34", :values => ["KZ"], :over => nil, :to => nil }
-      ]
-    }
-  end
-
-  it "should pick the values from column based file with multiple columns" do
-    results = GoodData::UserFilterBuilder.get_values(
-      COLUMN_BASED_DATA_WITH_HEADERS,
-      :type => :filter,
-      :user_column => :login,
-      :labels => [{ :label => "label/34", :column => :country }, { :label => "label/99", :column => :age }]
-    )
-    results.should == {
-      "tomas@gooddata.com" => [
-        { :label => "label/34", :values => ["US"], :over => nil, :to => nil },
-        { :label => "label/99", :values => [14], :over => nil, :to => nil }
-      ],
-     "petr@gooddata.com" => [
-       { :label => "label/34", :values => ["US"], :over => nil, :to => nil },
-       { :label => "label/99", :values => [19], :over => nil, :to => nil },
-       { :label => "label/34", :values => ["KZ"], :over => nil, :to => nil },
-       { :label => "label/99", :values => [30], :over => nil, :to => nil }
-      ]
-    }
-  end
-
-  it "should process end to end" do
-    result = GoodData::UserFilterBuilder.get_filters(
-      COLUMN_BASED_DATA_WITH_HEADERS,
-      :user_column => :login,
-      :labels => [{ :label => { :uri => "label/34" }, :column => :country }, { :label => { :uri => "label/99" }, :column => :age }]
-    )
-    result.should == [
-      {
-        :login => "tomas@gooddata.com",
-        :filters => [
-          { :label => { :uri => "label/34" }, :values => ["US"], :over => nil, :to => nil },
-          { :label => { :uri => "label/99" }, :values => [14], :over => nil, :to => nil }
-        ]
-      },
-      {
-        :login => "petr@gooddata.com",
-        :filters => [
-          { :label => { :uri => "label/34" }, :values => %w(US KZ), :over => nil, :to => nil },
-          { :label => { :uri => "label/99" }, :values => [19, 30], :over => nil, :to => nil }
-        ]
-      }
-    ]
-  end
-
-  it "should process end to end nil value should be ignored" do
-    result = GoodData::UserFilterBuilder.get_filters(
-      COLUMN_BASED_DATA_WITH_HEADERS_AND_NIL_VAL,
-      :user_column => :login,
-      :labels => [{ :label => { :uri => "label/34" }, :column => :country }, { :label => { :uri => "label/99" }, :column => :age }]
-    )
-    result.should == [
-      {
-        :login => "tomas@gooddata.com",
-        :filters => [
-          { :label => { :uri => "label/34" }, :values => ["US"], :over => nil, :to => nil },
-          { :label => { :uri => "label/99" }, :values => [14], :over => nil, :to => nil }
-        ]
-      },
-      {
-        :login => "petr@gooddata.com",
-        :filters => [
-          { :label => { :uri => "label/34" }, :values => %w(US KZ), :over => nil, :to => nil },
-          { :label => { :uri => "label/99" }, :values => [19], :over => nil, :to => nil }
-        ]
-      }
-    ]
-  end
-
-  it "should process end to end nil value should be ignored" do
-    result = GoodData::UserFilterBuilder.get_filters(
-      COLUMN_BASED_DATA_WITH_HEADERS_AND_EMPTY_VAL,
-      :user_column => :login,
-      :labels => [
-        { :label => { :uri => "label/34" }, :column => :country },
-        { :label => { :uri => "label/99" }, :column => :age }
-      ]
-    )
-    result.should == [
-      {
-        :login => "tomas@gooddata.com",
-        :filters => [
-          { :label => { :uri => "label/34" }, :values => ["US"], :over => nil, :to => nil },
-          { :label => { :uri => "label/99" }, :values => [14], :over => nil, :to => nil }
-        ]
-      },
-      {
-        :login => "petr@gooddata.com",
-        :filters => [
-          { :label => { :uri => "label/34" }, :values => %w(US KZ), :over => nil, :to => nil },
-          { :label => { :uri => "label/99" }, :values => [19, ""], :over => nil, :to => nil }
-        ]
-      }
-    ]
-  end
-
-  it "should collect values for every user" do
-    data = {
-      "tomas" => [
-        { :label => "label/34", :values => ["US"] },
-        { :label => "label/34", :values => ["KZ"] },
-        { :label => "label/99", :values => [18] },
-        { :label => "label/99", :values => [20] }
-      ],
-      "petr" => [
-        { :label => "label/34", :values => ["US"] },
-        { :label => "label/99", :values => [2] },
-        { :label => "label/99", :values => [1] }
-      ]
-    }
-    result = GoodData::UserFilterBuilder.reduce_results(data)
-    result.should == [
-      {
-        :login => "tomas",
-        :filters => [
-          { :label => "label/34", :values => %w(US KZ), :over => nil, :to => nil },
-          { :label => "label/99", :values => [18, 20], :over => nil, :to => nil }
-        ]
-      },
-      {
-        :login => "petr",
-        :filters => [
-          { :label => "label/34", :values => ["US"], :over => nil, :to => nil },
-          { :label => "label/99", :values => [2, 1], :over => nil, :to => nil }
-        ]
-      }
-    ]
-  end
-
-  it "should collect values for every label" do
-    data = [
-      { :label => "label/34", :values => ["US"] },
-      { :label => "label/34", :values => ["KZ"] },
-      { :label => "label/99", :values => [18] },
-      { :label => "label/99", :values => [20] }
-    ]
-    result = GoodData::UserFilterBuilder.collect_labels(data)
-    result.should == [
-      { :label => "label/34", :values => %w(US KZ), :over => nil, :to => nil },
-      { :label => "label/99", :values => [18, 20], :over => nil, :to => nil }
-    ]
-  end
-
-  it "should collect values" do
-    data = [
-      { :label => "label/34", :values => ["US"] },
-      { :label => "label/34", :values => ["KZ"] }
-    ]
-    results = GoodData::UserFilterBuilder.collect_values(data)
-    results.should == %w(US KZ)
-  end
-
-  it "should translate filters into MAQL filters" do
-    data = [
-      {
-        :login => "tomas@gooddata.com",
-        :filters => [
-          { :label => "label/34", :values => ["US"] },
-          { :label => "label/99", :values => [14] }
-        ]
-      },
-      {
-        :login => "petr@gooddata.com",
-        :filters => [
-          { :label => "label/34", :values => %w(US KZ) },
-          { :label => "label/99", :values => [19] }
-        ]
-      }
-    ]
-    results = data.map do |user_data|
-      {
-        :login => user_data[:login],
-        :maql_filter => user_data[:filters].map { |item| "[#{item[:label]}] IN (#{item[:values].join(', ')})" }.join(" AND ")
-      }
-    end
-    results.should == [
-      { :login => "tomas@gooddata.com", :maql_filter => "[label/34] IN (US) AND [label/99] IN (14)" },
-      { :login => "petr@gooddata.com", :maql_filter => "[label/34] IN (US, KZ) AND [label/99] IN (19)" }
-    ]
-  end
-end