gooddata 1.0.0-java

data/spec/unit/models/report_result_data_spec.rb

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

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

@@ -0,0 +1,110 @@
+# 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 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(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 receive(:delete)
+      result = subject.execute_mufs(filter_definitions, options)
+      expect(result[:created].length).to be(1)
+      expect(result[:deleted].length).to be(1)
+    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 '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
+
+      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
+  end
+end

data/spec/unit/models/user_filters_spec.rb

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