gooddata-edge 0.6.27.edge

data/spec/unit/models/blueprint/reference_spec.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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::Model::ReferenceBlueprintField do
+
+  before(:each) do
+    @model_view = MultiJson.load(File.read('./spec/data/wire_models/model_view.json'))
+    @blueprint = GoodData::Model::FromWire.from_wire(@model_view)
+    @dataset = @blueprint.datasets('dataset.opportunityanalysis')
+    @attribute = @dataset.attributes('attr.opportunityanalysis.month')
+  end
+
+  describe '#dataset' do
+    it 'should return labels on dataset' do
+      expect(@dataset.references.first.dataset.id).to eq 'dataset.opp_records'
+    end
+  end
+
+  describe '#reference' do
+    it 'should return reference on dataset' do
+      expect(@dataset.references.first.reference).to eq 'dataset.opp_records'
+    end
+  end
+end

data/spec/unit/models/blueprint/schema_builder_spec.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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 'pry'
+require 'gooddata/models/model'
+
+describe GoodData::Model::SchemaBuilder do
+
+  it "should create a schema" do
+    builder = GoodData::Model::SchemaBuilder.new("a_title")
+    blueprint = builder.to_blueprint
+    expect(blueprint.datasets.first.title).to eq 'A Title'
+  end
+
+  it "should create a schema with some columns" do
+    builder = GoodData::Model::SchemaBuilder.new("payments")
+    builder.add_attribute("id", :title => "My Id")
+    builder.add_fact("amount", :title => "Amount")
+
+    blueprint = builder.to_blueprint
+    blueprint.attributes.count == 1
+  end
+
+  it "should be able to create from block" do
+    builder = GoodData::Model::SchemaBuilder.create("payments") do |d|
+      d.add_attribute('attr.id', :title => 'Id')
+      d.add_label('label.id.name', :title => 'Id Name', reference: 'attr.id')
+      d.add_fact('amount', :title => 'Amount')
+    end
+
+    blueprint = builder.to_blueprint
+    blueprint.attributes.count == 1
+    blueprint.facts.count == 1
+  end
+end

data/spec/unit/models/blueprint/to_wire_spec.rb

@@ -0,0 +1,174 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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::ProjectBlueprint do
+
+  before(:each) do
+    @spec = JSON.parse(File.read("./spec/data/blueprints/big_blueprint_not_pruned.json"), :symbolize_names => true)
+    @blueprint = GoodData::Model::ProjectBlueprint.new(@spec)
+    @wire_spec = JSON.parse(File.read("./spec/data/wire_models/model_view.json"), :symbolize_names => true)
+  end
+
+  describe '#to_wire' do
+    it 'should transform small spec to wire' do
+      spec = JSON.parse(File.read("./spec/data/blueprints/test_blueprint.json"), :symbolize_names => true)
+      wire_spec = JSON.parse(File.read("./spec/data/wire_models/test_blueprint.json"), :symbolize_names => true)
+      res = ToWire.to_wire(spec)
+      expect(res).to eq wire_spec
+    end
+
+    it 'it should turn into wire another project' do
+      spec = JSON.parse(File.read("./spec/data/blueprints/test_project_model_spec.json"), :symbolize_names => true)
+      res = ToWire.to_wire(spec)
+    end
+
+    it 'should create manifest' do
+      spec = JSON.parse(File.read("./spec/data/blueprints/test_blueprint.json"), :symbolize_names => true)
+      wire_spec = JSON.parse(File.read("./spec/data/wire_models/test_blueprint.json"), :symbolize_names => true)
+      manifest_spec = JSON.parse(File.read("./spec/data/manifests/test_blueprint.json"))
+      expect(ToWire.to_wire(spec)).to eq wire_spec
+    end
+  end
+
+  describe '#anchor_to_wire' do
+    it 'should generate anchor without label.' do
+      dataset = ProjectBlueprint.find_dataset(@spec, 'dataset.stage_history')
+
+      result = ToWire.anchor_to_wire(@spec, dataset)
+      expect(result).to eq ({
+        attribute: {
+          identifier: "attr.dataset.stage_history.factsof",
+          title: "Records of stage_history",
+          folder: "stage_history"}})
+    end
+
+    it 'should generate anchor with label' do
+      dataset = ProjectBlueprint.find_dataset(@spec, 'dataset.opportunityanalysis')
+      result = ToWire.anchor_to_wire(nil, dataset)
+      expect(result).to eq ({
+        attribute: {
+          :identifier=>"attr.opportunityanalysis.techoppanalysis",
+          :title=>"Tech Opp. Analysis",
+          :folder=>"Opportunity Benchmark",
+          :labels=>[
+            {:label=>
+             {:identifier=>"label.opportunityanalysis.techoppanalysis",
+              :title=>"Tech Opp. Analysis",
+              :type=>"GDC.text",
+              :dataType=>"VARCHAR(128)"}}],
+          :defaultLabel=>"label.opportunityanalysis.techoppanalysis"}})
+    end
+  end
+
+  describe '#anchor_to_attribute' do
+    it 'should generate attribute without label' do
+      dataset = ProjectBlueprint.find_dataset(@spec, 'dataset.stage_history')
+      a = DatasetBlueprint.attributes(dataset).find {|a| a[:id] == 'attr.stage_history.currentstatus'}
+      result = ToWire.attribute_to_wire(dataset, a)
+      expect(result).to eq ({
+        :attribute=>
+        {:identifier=>"attr.stage_history.currentstatus",
+         :title=>"Current Stage",
+         :folder=>"stage_history",
+         :labels=>
+          [{:label=>
+             {:identifier=>"label.stage_history.currentstatus",
+              :title=>"Current Stage",
+              :type=>"GDC.text",
+              :dataType=>"VARCHAR(128)"}}],
+          :defaultLabel=>"label.stage_history.currentstatus"}})
+    end
+
+    it 'should generate attributes with label' do
+      dataset = ProjectBlueprint.find_dataset(@spec, 'dataset.opportunityanalysis')
+      a = DatasetBlueprint.attributes(dataset).find {|a| a[:id] == 'attr.opportunityanalysis.month'}
+
+      result = ToWire.attribute_to_wire(dataset, a)
+      expect(result).to eq ({:attribute=>
+        {:identifier=>"attr.opportunityanalysis.month",
+         :title=>"Month",
+         :folder=>"Opportunity Benchmark",
+         :labels=>
+          [{:label=>
+             {:identifier=>"label.opportunityanalysis.month",
+              :title=>"Month",
+              :type=>"GDC.text",
+              :dataType=>"VARCHAR(128)"}},
+           {:label=>
+             {:identifier=>"label.opportunityanalysis.month.monthsortingnew",
+              :title=>"MonthSortingNew",
+              :type=>"GDC.text",
+              :dataType=>"INT"}}],
+          :defaultLabel=>"label.opportunityanalysis.month" }})
+    end
+  end
+
+  describe '#fact_to_wire' do
+    it 'should generate anchor' do
+      fact_def = {
+        type: "fact",
+        id: "fact.stage_history.stage_velocity",
+        title: "Stage Velocity",
+        folder: "My Folder",
+        description: "Velocity description",
+        gd_data_type: "DECIMAL(12,2)"
+      }
+      result = ToWire.fact_to_wire(nil, fact_def)
+      expect(result).to eq ({
+        fact: {
+          identifier: "fact.stage_history.stage_velocity",
+          title: "Stage Velocity",
+          dataType: "DECIMAL(12,2)",
+          folder: "My Folder",
+          description: "Velocity description"}})
+    end
+  end
+
+  describe '#references_to_wire' do
+    it 'should produce references' do
+      dataset = ProjectBlueprint.find_dataset(@spec, 'dataset.opp_snapshot')
+      res = ToWire.references_to_wire(@spec, dataset)
+      expect(res).to eq [
+        "dataset.sdrowner",
+        "dataset.leadsourceoriginal",
+        "dataset.account",
+        "dataset.amounttype",
+        "dataset.product",
+        "dataset.sourcingorigin",
+        "dataset.leadsource",
+        "dataset.productline",
+        "dataset.stage",
+        "dataset.opp_owner",
+        "dataset.opportunity",
+        "dataset.bookingtype",
+        "dataset.forecast",
+        "leadcreate",
+        "snapshot",
+        "oppclose",
+        "oppcreated",
+        "stage1plus",
+        "mqldate",
+        "effectivecontractstart",
+        "effectivecontractend"
+      ]
+    end
+  end
+
+  describe '#date_dimension_to_wire' do
+    it 'should be able to generate date dimension' do
+      res = ToWire.date_dimension_to_wire(@spec, {
+        type: "date_dimension",
+        id: "timeline",
+        title: "Timeline"
+      })
+      expect(res).to eq({:dateDimension=>{:name=>"timeline", :title=>"Timeline"}})
+    end
+  end
+end

data/spec/unit/models/domain_spec.rb

@@ -0,0 +1,144 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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/domain'
+require 'gooddata/helpers/csv_helper'
+
+describe GoodData::Domain do
+  before(:each) do
+    @client = ConnectionHelper.create_default_connection
+    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+  end
+
+  after(:each) do
+    @client.disconnect
+  end
+
+  describe '#add_user' do
+    before(:each) do
+      @user = nil
+    end
+
+    after(:each) do
+      @user.delete if @user
+    end
+
+    it 'Should add user using class method' do
+      args = {
+        :domain => ConnectionHelper::DEFAULT_DOMAIN,
+        :login => "gemtest_#{rand(1e6)}@gooddata.com",
+        :password => CryptoHelper.generate_password,
+      }
+
+      @user = GoodData::Domain.add_user(args)
+      expect(@user).to be_an_instance_of(GoodData::Profile)
+    end
+
+    it 'Should add user using instance method' do
+      domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+
+      login = "gemtest#{rand(1e6)}@gooddata.com"
+      password = CryptoHelper.generate_password
+
+      @user = domain.add_user(:login => login, :password => password, :first_name => 'X', :last_name => 'X')
+      expect(@user).to be_an_instance_of(GoodData::Profile)
+    end
+  end
+
+  describe '#find_user_by_login' do
+    it 'Should find user by login' do
+      domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
+      user = domain.find_user_by_login(ConnectionHelper::DEFAULT_USERNAME)
+      # user = @domain.add_user(args, client: @client)
+      expect(user).to be_an_instance_of(GoodData::Profile)
+      expect(user.login).to eq ConnectionHelper::DEFAULT_USERNAME
+    end
+  end
+
+  describe '#users' do
+    it 'Should list users' do
+      users = @domain.users
+      expect(users).to be_instance_of(Enumerator)
+      users.each do |user|
+        expect(user).to be_an_instance_of(GoodData::Profile)
+      end
+    end
+  end
+
+  describe '#create_users' do
+    it 'Creates new users from list' do
+      list = (0..1).to_a.map { |i| ProjectHelper.create_random_user(@client) }
+      res = @domain.create_users(list)
+
+      # no errors
+      expect(res.select { |x| x[:type] == :successful && x[:action] == :user_added_to_domain }.count).to eq res.count
+
+      expect(@domain.members?(list.map(&:login)).all?).to be_truthy
+
+      res.select { |x| x[:type] == :successful }.map { |r| r[:user] }.each do |r|
+        expect(r).to be_an_instance_of(GoodData::Profile)
+        r.delete
+      end
+    end
+
+    it 'Update a user' do
+      user = @domain.users.reject { |u| u.login == @client.user.login }.sample
+      login = user.login
+      name = user.first_name
+      modes = user.authentication_modes
+      possible_modes = [:sso, :password]
+
+
+      user.first_name = name.reverse
+      choice = SpecHelper.random_choice(possible_modes, user.authentication_modes)
+      user.authentication_modes = choice
+      @domain.create_users([user])
+      changed_user = @domain.get_user(login)
+      expect(changed_user.first_name).to eq name.reverse
+      expect(changed_user.authentication_modes).to eq [choice]
+
+      user.first_name = name
+      user.authentication_modes = modes
+      @domain.create_users([user])
+      reverted_user = @domain.get_user(login)
+      expect(reverted_user.first_name).to eq name
+      expect(reverted_user.authentication_modes).to eq modes
+    end
+
+    it 'Fails with an exception if you try to create a user that is in a different domain' do
+      user = ProjectHelper.create_random_user(@client)
+      user.login = 'svarovsky@gooddata.com'
+      expect do
+        @domain.create_user(user)
+      end.to raise_exception(GoodData::UserInDifferentDomainError)
+    end
+
+    it 'updates properties of a profile' do
+      user = @domain.users
+        .reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }.take(20).sample
+
+      old_email = user.email
+      old_sso_provider = user.sso_provider || ''
+      user.email = 'john.doe@gooddata.com'
+      user.sso_provider = 'some_sso_provider'
+      @domain.update_user(user)
+      updated_user = @domain.find_user_by_login(user.login)
+      expect(updated_user.email).to eq 'john.doe@gooddata.com'
+      expect(updated_user.sso_provider).to eq 'some_sso_provider'
+
+      updated_user.sso_provider = 'some_sso_provider'.reverse
+      @domain.update_user(updated_user)
+      updated_user = @domain.find_user_by_login(user.login)
+      expect(updated_user.sso_provider).to eq 'some_sso_provider'.reverse
+
+      updated_user.email = old_email
+      updated_user.sso_provider = old_sso_provider
+      @domain.update_user(updated_user)
+      expect(@domain.find_user_by_login(user.login).email).to eq old_email
+      expect(@domain.find_user_by_login(user.login).sso_provider).to eq old_sso_provider
+    end
+  end
+end

data/spec/unit/models/execution_spec.rb

@@ -0,0 +1,108 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 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/schedule'
+
+describe GoodData::Execution do
+
+  before(:each) do
+    @data = {"execution"=>
+      {"startTime"=>"2015-02-27T15:44:21.759Z",
+       "endTime"=>"2015-02-27T15:47:49.383Z",
+       "log"=>
+        "/gdc/projects/tk3b994vmdpcb0xjwexc9moen8t5bpiw/dataload/processes/2b031451-b1a2-4039-8e36-0672542a0e60/executions/54f090d5e4b0c9cbdcb0f45b/log",
+       "status"=>"OK",
+       "trigger"=>"MANUAL",
+       "links"=>
+        {"self"=>
+          "/gdc/projects/tk3b994vmdpcb0xjwexc9moen8t5bpiw/schedules/54f08d1de4b0c9cbdcb0f323/executions/54f090d5e4b0c9cbdcb0f45b"},
+       "createdTime"=>"2015-02-27T15:44:21.361Z"}}
+    @execution = GoodData::Execution.new(@data)
+  end
+
+  describe '#created' do
+    it 'returns created as a Time instance' do
+      expect(@execution.created.class).to eq Time
+      expect(@execution.created.to_s).to eq '2015-02-27 15:44:21 UTC'
+    end
+  end
+
+  describe '#error?' do
+    it 'returns true if executione errored out' do
+      expect(@execution.error?).to be_falsy
+    end
+  end
+
+  describe '#ok?' do
+    it 'returns true if executione finished ok' do
+      expect(@execution.ok?).to be_truthy
+    end
+  end
+
+  describe '#finished' do
+    it 'returns time when execution finished' do
+      expect(@execution.finished.class).to eq Time
+      expect(@execution.finished.to_s).to eq '2015-02-27 15:47:49 UTC'
+    end
+
+    it 'returns nil if it is not finished' do
+      @data['execution']['status'] = 'RUNNING'
+      @data['execution']['endTime'] = nil
+      running_execution = GoodData::Execution.new(@data)
+      expect(running_execution.finished).to be_nil
+    end
+  end
+
+  describe '#schedule_uri' do
+    it 'returns uri of schedule that was executed' do
+      expect(@execution.schedule_uri).to eq '/gdc/projects/tk3b994vmdpcb0xjwexc9moen8t5bpiw/schedules/54f08d1de4b0c9cbdcb0f323'
+    end
+  end
+
+  describe '#running?' do
+    it 'returns false if executione is already finished' do
+      expect(@execution.running?).to be_falsy
+    end
+
+    it 'returns true if executione is currently finished' do
+      @data['execution']['status'] = 'RUNNING'
+      running_execution = GoodData::Execution.new(@data)
+      expect(running_execution.running?).to be_truthy
+    end
+  end
+
+  describe '#started' do
+    it 'returns time when execution started' do
+      expect(@execution.started.class).to eq Time
+      expect(@execution.started.to_s).to eq '2015-02-27 15:44:21 UTC'
+    end
+  end
+
+  describe '#status' do
+    it 'returns :ok for finished execution' do
+      expect(@execution.status).to eq :ok
+    end
+  end
+
+  describe '#uri' do
+    it 'returns time when execution started' do
+      expect(@execution.uri).to eq '/gdc/projects/tk3b994vmdpcb0xjwexc9moen8t5bpiw/schedules/54f08d1de4b0c9cbdcb0f323/executions/54f090d5e4b0c9cbdcb0f45b'
+    end
+  end
+
+  describe '#duration' do
+    it 'returns time it took to run execution' do
+      expect(@execution.duration).to eq 207.624
+    end
+
+    it 'returns nil if it is not finished' do
+      @data['execution']['status'] = 'RUNNING'
+      @data['execution']['endTime'] = nil
+      running_execution = GoodData::Execution.new(@data)
+      expect(running_execution.duration.class).to eq Float
+    end
+  end
+end