gooddata 1.1.0 → 1.2.0

data/spec/unit/models/report_result_data_spec.rb

@@ -1,194 +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/models/report_data_result'
-
-describe GoodData::ReportDataResult do
-  before(:each) do
-    data = JSON.parse(File.read('./spec/data/reports/report_1.json'))
-    @result = GoodData::ReportDataResult.from_xtab(data)
-    @result2 = GoodData::ReportDataResult.from_xtab(data)
-  end
-
-  it 'should compute columns' do
-    expect(@result.to_a).to eq [[nil, "kolin", "praha", "varsava"],
-                                [nil, "sum of Age", "sum of Age", "sum of Age"],
-                                ["jirka", 25, nil, nil],
-                                ["petr", nil, nil, 15],
-                                ["tomas", nil, 25, nil]]
-  end
-
-  it 'should compute columns' do
-    expect(@result.left_headers).to eq [["jirka"],
-                                        ["petr"],
-                                        ["tomas"]]
-  end
-
-  it 'should compute columns' do
-    expect(@result.top_headers).to eq [%w(kolin praha varsava), ["sum of Age", "sum of Age", "sum of Age"]]
-  end
-
-  describe '#slice' do
-    it 'slice on zeroes should be equal to original' do
-      expect(@result.slice(0, 0)).to eq @result
-    end
-
-    it 'slice on data should return just data' do
-      expect(@result.slice(2, 1).to_a).to eq [[25, nil, nil],
-                                              [nil, nil, 15],
-                                              [nil, 25, nil]]
-    end
-
-    it 'should return data result with correct size' do
-      expect(@result.slice(2, 1).size).to eq [3, 3]
-    end
-
-    it 'should return data result with correct headers' do
-      expect(@result.left_headers).to eq [["jirka"], ["petr"], ["tomas"]]
-      expect(@result.top_headers).to eq [%w(kolin praha varsava), ["sum of Age", "sum of Age", "sum of Age"]]
-    end
-  end
-
-  describe '#without_left_headers' do
-    it 'should return data result without left headers' do
-      expect(@result.without_left_headers.to_a).to eq [%w(kolin praha varsava),
-                                                       ["sum of Age", "sum of Age", "sum of Age"],
-                                                       [25, nil, nil],
-                                                       [nil, nil, 15],
-                                                       [nil, 25, nil]]
-    end
-
-    it 'should return correct size' do
-      expect(@result.without_left_headers.size).to eq [5, 3]
-    end
-
-    it 'should return correct left headers' do
-      expect(@result.without_top_headers.top_headers).to eq nil
-    end
-  end
-
-  describe '#without_top_headers' do
-    it 'should return data result without left headers' do
-      expect(@result.without_top_headers.to_a).to eq [["jirka", 25, nil, nil],
-                                                      ["petr", nil, nil, 15],
-                                                      ["tomas", nil, 25, nil]]
-    end
-
-    it 'should return correct size' do
-      expect(@result.without_top_headers.size).to eq [3, 4]
-    end
-
-    it 'should return correct left headers' do
-      expect(@result.without_top_headers.left_headers).to eq [["jirka"],
-                                                              ["petr"],
-                                                              ["tomas"]]
-    end
-
-    it 'should return correct top headers' do
-      expect(@result.without_top_headers.top_headers).to eq nil
-    end
-  end
-
-  it 'should work with left attribute reports' do
-    data = JSON.parse(File.read('./spec/data/reports/left_attr_report.json'))
-    result = GoodData::ReportDataResult.from_xtab(data)
-    expect(result.left_headers).to eq [["jirka"], ["petr"], ["tomas"]]
-    expect(result.size).to eq [4, 2]
-    expect(result.data_size).to eq [3, 1]
-  end
-
-  it 'should work with left attribute reports' do
-    data = JSON.parse(File.read('./spec/data/reports/top_attr_report.json'))
-    result = GoodData::ReportDataResult.from_xtab(data)
-    expect(result.size).to eq [2, 4]
-    expect(result.data_size).to eq [1, 3]
-    expect(result.left_headers).to eq [["Values"]]
-    expect(result.top_headers).to eq [%w(jirka petr tomas)]
-  end
-
-  it 'should fail when comparing two different reports' do
-    data = JSON.parse(File.read('./spec/data/reports/left_attr_report.json'))
-    a = GoodData::ReportDataResult.from_xtab(data)
-    data = JSON.parse(File.read('./spec/data/reports/top_attr_report.json'))
-    b = GoodData::ReportDataResult.from_xtab(data)
-    expect(a == b).to be_falsey
-  end
-
-  describe '#size' do
-    it 'should compute columns' do
-      expect(@result.size).to eq [5, 4]
-    end
-
-    it 'should compute columns' do
-      expect(@result.size).to eq @result2.size
-    end
-  end
-
-  describe '#data' do
-    it 'should return just data portion' do
-      expect(@result.data.is_a?(GoodData::ReportDataResult)).to be_truthy
-      expect(@result.data.to_a).to eq [[25, nil, nil],
-                                       [nil, nil, 15],
-                                       [nil, 25, nil]]
-    end
-  end
-
-  describe '#[]' do
-    it 'should return correct line' do
-      expect(@result[2]).to eq ['jirka', 25, nil, nil]
-    end
-  end
-
-  describe '#column' do
-    it 'should return correct line' do
-      expect(@result.column(2)).to eq ["praha", "sum of Age", nil, nil, 25]
-    end
-  end
-
-  describe '#map' do
-    it 'should iterate over rows' do
-      expect(@result.each.map { [1] }).to eq [[1], [1], [1], [1], [1]]
-    end
-  end
-
-  describe '#transpose' do
-    it 'should transpose' do
-      expect(@result.transpose.to_a).to eq @result.to_a.transpose
-      expect(@result.transpose.to_a).to eq [[nil, nil, "jirka", "petr", "tomas"],
-                                            ["kolin", "sum of Age", 25, nil, nil],
-                                            ["praha", "sum of Age", nil, nil, 25],
-                                            ["varsava", "sum of Age", nil, 15, nil]]
-    end
-  end
-
-  describe '#diff' do
-    it 'should support diffing' do
-      data = JSON.parse(File.read('./spec/data/reports/left_attr_report.json'))
-      a = GoodData::ReportDataResult.from_xtab(data)
-      c = GoodData::ReportDataResult.from_xtab(data)
-      data = JSON.parse(File.read('./spec/data/reports/top_attr_report.json'))
-      b = GoodData::ReportDataResult.from_xtab(data)
-      expect { a - b }.to raise_exception
-      expect(a - c).to be_empty
-    end
-  end
-
-  describe 'one line reports' do
-    it 'should work with one line metric. No attribtues.' do
-      data = JSON.parse(File.read('./spec/data/reports/metric_only_one_line.json'))
-      a = GoodData::ReportDataResult.from_xtab(data)
-      expect(a.to_a).to eq [[nil, "sum of Age"],
-                            ["sum of Age", 65]]
-
-      expect(a.data.to_a).to eq [[65]]
-      expect(a.left_headers).to eq [["sum of Age"]]
-      expect(a.top_headers).to eq [["sum of Age"]]
-
-      expect(a.without_top_headers.to_a).to eq [["sum of Age", 65]]
-      expect(a.without_left_headers.to_a).to eq [["sum of Age"], [65]]
-    end
-  end
-end

data/spec/unit/models/to_manifest_spec.rb

@@ -1,165 +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'
-
-include GoodData::Model
-
-describe GoodData::Model::ToManifest do
-  before(:each) do
-    @spec = JSON.parse(File.read("./spec/data/blueprints/test_project_model_spec.json"), :symbolize_names => true)
-    @result = JSON.parse(File.read("./spec/data/manifests/test_project.json"))
-  end
-
-  it "should parse the model view and return the blueprint" do
-    expect(ToManifest.to_manifest(@spec)).to eq @result
-  end
-
-  context 'when HLL fact is in the spec' do
-    let(:hll_fact) do
-      {
-        type: "hll",
-        id: 'fact.commits.lines_added',
-        column_name: 'lines_added',
-        title: 'Lines Added'
-      }
-    end
-
-    let(:spec) do
-      hll_spec = @spec
-      hll_spec[:datasets]
-        .find { |d| d[:id] == 'dataset.commits' }[:columns] << hll_fact
-      hll_spec
-    end
-
-    it "converts the HLL fact to manifest" do
-      actual = ToManifest.to_manifest(spec)
-      expected = {
-        'populates' => ['fact.commits.lines_added'],
-        'mode' => 'FULL',
-        'columnName' => 'lines_added'
-      }
-      parts = actual[2]['dataSetSLIManifest']['parts']
-      expect(parts).to include(expected)
-    end
-  end
-
-  it 'blueprint can be set with date reference and default format is set' do
-    blueprint = GoodData::Model::ProjectBlueprint.build("my_bp") do |p|
-      p.add_date_dimension("committed_on")
-
-      p.add_dataset("repos") do |d|
-        d.add_anchor("repo_id")
-        d.add_attribute("name")
-        d.add_date('opportunity_comitted', dataset: 'committed_on')
-      end
-    end
-    expect(blueprint.to_manifest.first['dataSetSLIManifest']['parts'][0]['constraints']).to eq("date" => GoodData::Model::DEFAULT_DATE_FORMAT)
-  end
-
-  it 'blueprint can be set with date reference and default format is set' do
-    blueprint = GoodData::Model::ProjectBlueprint.build("my_bp") do |p|
-      p.add_date_dimension("committed_on")
-
-      p.add_dataset("repos") do |d|
-        d.add_anchor("repo_id")
-        d.add_attribute("name")
-        d.add_date('opportunity_comitted', dataset: 'committed_on', format: 'yyyy/MM/dd')
-      end
-    end
-    expect(blueprint.to_manifest.first['dataSetSLIManifest']['parts'][0]['constraints']).to eq("date" => "yyyy/MM/dd")
-  end
-
-  it 'blueprint can handle date fact during creation of manifest' do
-    blueprint = GoodData::Model::ProjectBlueprint.build("my_bp") do |p|
-      p.add_date_dimension("committed_on")
-
-      p.add_dataset("repos") do |d|
-        d.add_anchor("repo_id")
-        d.add_label("repo_label", reference: "repo_id")
-        d.add_attribute("name")
-        d.add_label("name_label", reference: "name")
-        d.add_date('opportunity_comitted', dataset: 'committed_on', format: 'yyyy/MM/dd')
-        d.add_column(type: :date_fact, id: 'dt.date_fact')
-      end
-    end
-    expect(blueprint.to_manifest.first['dataSetSLIManifest']['parts'].count).to eq 4
-  end
-
-  it 'blueprint can be specified to have a reference key. The manifest respects it. If not it takes the first key.' do
-    blueprint = GoodData::Model::ProjectBlueprint.build("my_bp") do |p|
-      p.add_date_dimension("committed_on")
-
-      p.add_dataset("repos") do |d|
-        d.add_anchor("repo_id")
-        d.add_label("repo_label_1", reference: "repo_id")
-        d.add_label("repo_label_2", reference: "repo_id")
-        d.add_attribute("name")
-        d.add_label("name_label", reference: "name")
-
-        d.add_date('opportunity_comitted', dataset: 'committed_on', format: 'yyyy/MM/dd')
-        d.add_column(type: :date_fact, id: 'dt.date_fact')
-      end
-    end
-    expect(blueprint.to_manifest.first['dataSetSLIManifest']['parts'])
-      .to include("referenceKey" => 1,
-                  "populates" => ["repo_label_1"],
-                  "mode" => "FULL",
-                  "columnName" => "repo_label_1")
-
-    blueprint = GoodData::Model::ProjectBlueprint.build("my_bp") do |p|
-      p.add_date_dimension("committed_on")
-
-      p.add_dataset("repos") do |d|
-        d.add_anchor("repo_id")
-        d.add_label("repo_label_1", reference: "repo_id")
-        d.add_label("repo_label_2", reference: "repo_id", reference_label: true)
-        d.add_attribute("name")
-        d.add_label("name_label", reference: "name")
-
-        d.add_date('opportunity_comitted', dataset: 'committed_on', format: 'yyyy/MM/dd')
-      end
-
-      p.add_dataset("commits") do |d|
-        d.add_anchor("commits_id")
-        d.add_fact('lines')
-        d.add_reference('repos')
-      end
-    end
-
-    expect(blueprint.to_manifest.first['dataSetSLIManifest']['parts'])
-      .to include("referenceKey" => 1,
-                  "populates" => ["repo_label_2"],
-                  "mode" => "FULL",
-                  "columnName" => "repo_label_2")
-    expect(blueprint.to_manifest[1]['dataSetSLIManifest']['parts']).to include("populates" => ["repo_label_2"], "mode" => "FULL", "columnName" => "repos", "referenceKey" => 1)
-  end
-
-  it 'blueprint cannot have more than one reference key.' do
-    blueprint = GoodData::Model::ProjectBlueprint.build("my_bp") do |p|
-      p.add_date_dimension("committed_on")
-
-      p.add_dataset("repos") do |d|
-        d.add_anchor("repo_id")
-        d.add_label("repo_label_1", reference: "repo_id", reference_label: true)
-        d.add_label("repo_label_2", reference: "repo_id", reference_label: true)
-        d.add_attribute("name")
-        d.add_label("name_label", reference: "name")
-
-        d.add_date('opportunity_comitted', dataset: 'committed_on', format: 'yyyy/MM/dd')
-        d.add_column(type: :date_fact, id: 'dt.date_fact')
-      end
-    end
-
-    expect(blueprint.valid?).to be false
-    expect(blueprint.validate).to eq [
-      {
-        type: :error,
-        message: "Anchor \"repo_id\" can have only one label with reference_label field set to true"
-      }
-    ]
-  end
-end

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