gooddata 1.1.0 → 1.2.0

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

@@ -1,28 +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'
-
-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

@@ -1,36 +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/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

@@ -1,196 +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::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: {
-          type: "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/dataset_blueprint.rb

@@ -1,14 +0,0 @@
-describe GoodData::Model::DatasetBlueprint do
-  let(:dataset) do
-    { columns: [{ type: 'hll' },
-                { type: 'fact' },
-                { type: 'date_fact' }] }
-  end
-  subject { GoodData::Model::DatasetBlueprint }
-  describe '.facts' do
-    it 'returns facts of supported types' do
-      result = subject.facts(dataset)
-      expect(result).to eq(dataset[:columns])
-    end
-  end
-end

data/spec/unit/models/execution_spec.rb

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

@@ -1,321 +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::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
-
-    it 'supports hll' do
-      model = @model_view['projectModelView']['model']['projectModel']['datasets'].first
-      hll_fact = { "fact" => {
-        "identifier" => "hll_test",
-        "title" => "Test HLL Fact",
-        "dataType" => "HLL",
-        'type' => 'hll'
-      } }
-      model['dataset']['facts'] << hll_fact
-      expected = {
-        type: :hll,
-        id: "hll_test",
-        title: "Test HLL Fact",
-        gd_data_type: "HLL",
-        folder: nil
-      }
-      facts = GoodData::Model::FromWire.parse_facts(model)
-      expect(facts).to include(expected)
-    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