gooddata 1.0.0-java

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

@@ -0,0 +1,28 @@
+# 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::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,36 @@
+# 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/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
+    expect(blueprint.attributes.count).to eq(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
+    expect(blueprint.attributes.count).to eq(1)
+    expect(blueprint.facts.count).to eq(1)
+  end
+end

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

@@ -0,0 +1,195 @@
+# 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::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)
+      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)
+      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 { |attribute| attribute[: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 { |attribute| attribute[: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/execution_spec.rb

@@ -0,0 +1,109 @@
+# 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/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_falsey
+    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_falsey
+    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

data/spec/unit/models/from_wire_spec.rb

@@ -0,0 +1,301 @@
+# 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::FromWire do
+  before(:each) do
+    @model_view = MultiJson.load(File.read('./spec/data/wire_models/model_view.json'))
+    @blueprint = FromWire.from_wire(@model_view)
+  end
+
+  describe '#parse_label' do
+    it "should be able to parse the attribute" do
+      model = @model_view['projectModelView']['model']['projectModel']['datasets'][3]
+      a = FromWire.parse_attribute(model['dataset']['attributes'].first['attribute'])
+      expect(a.to_set).to eq Set.new([
+        {
+          type: :attribute,
+          id: "attr.opportunityanalysis.month",
+          title: "Month",
+          folder: "Opportunity Benchmark",
+          description: nil,
+          order_by: "label.opportunityanalysis.month.monthsortingnew - ASC"
+        },
+        {
+          type: :label,
+          id: "label.opportunityanalysis.month",
+          reference: "attr.opportunityanalysis.month",
+          title: "Month",
+          gd_data_type: "VARCHAR(128)",
+          gd_type: "GDC.text",
+          default_label: true
+        },
+        {
+          type: :label,
+          id: "label.opportunityanalysis.month.monthsortingnew",
+          reference: "attr.opportunityanalysis.month",
+          title: "MonthSortingNew",
+          gd_data_type: "INT",
+          gd_type: "GDC.text"
+        }
+      ])
+    end
+
+    it "should be able to parse the anchor" do
+      model = @model_view['projectModelView']['model']['projectModel']['datasets'][3]
+      x = FromWire.parse_attribute(model['dataset']['anchor']['attribute'], :anchor)
+      expect(x.to_set).to eq Set.new([
+        {
+          type: :anchor,
+          id: "attr.opportunityanalysis.techoppanalysis",
+          title: "Tech Opp. Analysis",
+          folder: "Opportunity Benchmark",
+          description: nil
+        },
+        {
+          type: :label,
+          id: "label.opportunityanalysis.techoppanalysis",
+          title: "Tech Opp. Analysis",
+          reference: "attr.opportunityanalysis.techoppanalysis",
+          gd_data_type: "VARCHAR(128)",
+          gd_type: "GDC.text",
+          default_label: true
+        }
+      ])
+    end
+  end
+
+  describe '#parse_attributes' do
+    it "should be able to parse the attributes with one label" do
+      model = @model_view['projectModelView']['model']['projectModel']['datasets'].first
+      x = FromWire.parse_attributes(model)
+      expect(x.to_set).to eq Set.new([
+        {
+          type: :attribute,
+          id: "attr.stage_history.currentstatus",
+          title: "Current Stage",
+          description: nil,
+          folder: nil
+        },
+        {
+          type: :label,
+          id: "label.stage_history.currentstatus",
+          reference: "attr.stage_history.currentstatus",
+          title: "Current Stage",
+          gd_data_type: "VARCHAR(128)",
+          gd_type: "GDC.text",
+          default_label: true
+        }
+      ])
+    end
+
+    it "should be able to parse the attributes with several labels" do
+      model = @model_view['projectModelView']['model']['projectModel']['datasets'][3]
+      x = FromWire.parse_attributes(model)
+      expect(x.to_set).to eq Set.new([
+        {
+          type: :attribute,
+          id: "attr.opportunityanalysis.month",
+          title: "Month",
+          description: nil,
+          folder: "Opportunity Benchmark",
+          order_by: "label.opportunityanalysis.month.monthsortingnew - ASC"
+        },
+        {
+          type: :label,
+          reference: "attr.opportunityanalysis.month",
+          id: "label.opportunityanalysis.month",
+          title: "Month",
+          gd_data_type: "VARCHAR(128)",
+          gd_type: "GDC.text",
+          default_label: true
+        },
+        {
+          type: :label,
+          id: "label.opportunityanalysis.month.monthsortingnew",
+          reference: "attr.opportunityanalysis.month",
+          title: "MonthSortingNew",
+          gd_data_type: "INT",
+          gd_type: "GDC.text"
+        },
+        {
+          type: :attribute,
+          id: "attr.opportunityanalysis.cohorttype",
+          title: "Cohort Type",
+          description: nil,
+          folder: "Opportunity Benchmark"
+        },
+        {
+          type: :label,
+          id: "label.opportunityanalysis.cohorttype",
+          reference: "attr.opportunityanalysis.cohorttype",
+          title: "Cohort Type",
+          gd_data_type: "VARCHAR(128)",
+          gd_type: "GDC.text",
+          default_label: true
+        }
+      ])
+    end
+
+    it "should be able to parse the attributes with no labels" do
+      model = @model_view['projectModelView']['model']['projectModel']['datasets'][7]
+      x = FromWire.parse_attributes(model)
+      expect(x.to_set).to eq Set.new
+    end
+  end
+
+  describe '#parse_anchor' do
+    it "should be able to parse the anchor without label" do
+      model = @model_view['projectModelView']['model']['projectModel']['datasets'].first
+      x = FromWire.parse_anchor(model)
+      expect(x.to_set).to eq Set.new([
+        {
+          type: :anchor,
+          id: "attr.stage_history.factsof",
+          title: "Records of stage_history",
+          description: nil,
+          folder: nil
+        }
+      ])
+    end
+
+    it "should be able to parse the anchor out of dataset when there are multiple labels" do
+      model = @model_view['projectModelView']['model']['projectModel']['datasets'][7]
+      x = FromWire.parse_anchor(model)
+      expect(x.to_set).to eq Set.new([
+        {
+          type: :anchor,
+          id: "attr.opp_records.factsof",
+          title: "Records of opp_records",
+          description: nil,
+          folder: nil
+        },
+        {
+          type: :label,
+          id: "label.opp_records.opp_records_conctn_point",
+          reference: "attr.opp_records.factsof",
+          title: "opp_records_conctn_point",
+          gd_data_type: "VARCHAR(128)",
+          gd_type: "GDC.text",
+          default_label: true
+        },
+        {
+          type: :label,
+          id: "label.opp_records.factsof",
+          reference: "attr.opp_records.factsof",
+          title: "Records of opp_records",
+          gd_data_type: "VARCHAR(128)",
+          gd_type: "GDC.text"
+        }
+      ])
+    end
+  end
+
+  describe '#parse_facts' do
+    it 'should be able to parse facts from dataset' do
+      model = @model_view['projectModelView']['model']['projectModel']['datasets'].first
+      facts = GoodData::Model::FromWire.parse_facts(model)
+      expect(facts.to_set).to eq Set.new([
+        {
+          type: :fact,
+          id: "fact.stage_history.stage_velocity",
+          title: "Stage Velocity",
+          description: "Velocity description",
+          gd_data_type: "DECIMAL(12,2)",
+          folder: nil
+        },
+        {
+          type: :fact,
+          id: "fact.stage_history.stage_duration",
+          title: "Stage Duration",
+          gd_data_type: "DECIMAL(12,2)",
+          folder: nil
+        },
+        {
+          type: :date_fact,
+          id: "dt.stage_history.opp_created_date",
+          title: "Opp. Created (Date) for Stage History",
+          gd_data_type: "INT",
+          folder: nil
+        },
+        {
+          type: :date_fact,
+          id: "dt.stage_history.opp_close_date",
+          title: "Opp. Close (Date) for Stage History",
+          gd_data_type: "INT",
+          folder: nil
+        }
+      ])
+    end
+  end
+
+  describe '#parse_dataset' do
+    it 'should be able to parse dataset' do
+      model_view = MultiJson.load(File.read('./spec/data/wire_models/nu_model.json'))
+      dataset = GoodData::Model::FromWire.dataset_from_wire(model_view['projectModelView']['model']['projectModel']['datasets'].first)
+      expect(dataset).to have_key(:type)
+      expect(dataset[:type]).to eq :dataset
+      expect(dataset[:id]).to eq 'dataset.bookingsactual'
+      expect(dataset[:columns].select { |c| c[:type] == :attribute }.count).to eq 15
+      expect(dataset[:columns].select { |c| c[:type] == :fact }.count).to eq 3
+      expect(dataset[:columns].select { |c| c[:type] == :reference }.count).to eq 6
+      expect(dataset[:columns].select { |c| c[:type] == :date }.count).to eq 5
+    end
+  end
+
+  describe '#from_wire' do
+    it 'should be able to parse dataset' do
+      model_view = MultiJson.load(File.read('./spec/data/wire_models/nu_model.json'))
+      GoodData::Model::FromWire.from_wire(model_view)
+    end
+  end
+
+  it "should parse the model view and return the blueprint" do
+    expect(@blueprint.datasets.count).to eq 28
+  end
+
+  it "should have a datatype if defined" do
+    dataset = @blueprint.datasets.find { |d| d.id == 'dataset.account' }
+    dataset.labels_for_attribute('attr.account.accountemployeecount')
+
+    dataset = @blueprint.find_dataset('dataset.stage_history')
+    col = dataset.find_column_by_id('fact.stage_history.stage_duration')
+    expect(col.gd_data_type).to eq 'DECIMAL(12,2)'
+  end
+
+  it "should have a datatype if defined" do
+    col = @blueprint.find_dataset('dataset.stage_history').labels('label.stage_history.currentstatus')
+    expect(col.gd_type).to eq 'GDC.text'
+  end
+
+  it "should validate a gd_type" do
+    expect(GoodData::Model.check_gd_type("GDC.time")).to eq true
+    expect(GoodData::Model.check_gd_type("gdc.time")).to eq false
+    expect(GoodData::Model.check_gd_type("gdc.time3")).to eq false
+  end
+
+  it "should validate a gd_datatype" do
+    expect(GoodData::Model.check_gd_data_type("INT")).to eq true
+    expect(GoodData::Model.check_gd_data_type("int")).to eq true
+    expect(GoodData::Model.check_gd_data_type("VARCHAR(128)")).to eq true
+    expect(GoodData::Model.check_gd_data_type("varchar(128)")).to eq true
+    expect(GoodData::Model.check_gd_data_type("DECIMAL(10, 5)")).to eq true
+    expect(GoodData::Model.check_gd_data_type("DECIMAL(10,5)")).to eq true
+    expect(GoodData::Model.check_gd_data_type("DECIMAL(10,  5)")).to eq true
+    expect(GoodData::Model.check_gd_data_type("decimal(10, 5)")).to eq true
+    expect(GoodData::Model.check_gd_data_type("decimal(10,5)")).to eq true
+    expect(GoodData::Model.check_gd_data_type("decimal(10,  5)")).to eq true
+  end
+
+  it "should be able to parse description from both attributes and facts" do
+    expect(@blueprint.find_dataset('dataset.opportunity').anchor.description).to eq 'This is opportunity attribute description'
+    expect(@blueprint.find_dataset('dataset.stage_history').facts.find { |f| f.id == 'fact.stage_history.stage_velocity' }.description).to eq 'Velocity description'
+    expect(@blueprint.find_dataset('dataset.opp_owner').attributes.find { |f| f.id == 'attr.opp_owner.region' }.description).to eq 'Owner Region description'
+  end
+end