gooddata 0.6.18 → 0.6.19

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

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+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/{schema_builder_spec.rb → blueprint/schema_builder_spec.rb}

@@ -6,12 +6,9 @@ require 'gooddata/models/model'
 describe GoodData::Model::SchemaBuilder do
 
   it "should create a schema" do
-    # pending("Using of humanize")
-
     builder = GoodData::Model::SchemaBuilder.new("a_title")
     blueprint = builder.to_blueprint
-    blueprint.title.should == "A Title"
-    blueprint.name.should == "a_title"
+    expect(blueprint.datasets.first.title).to eq 'A Title'
   end
 
   it "should create a schema with some columns" do
@@ -23,4 +20,15 @@ describe GoodData::Model::SchemaBuilder do
     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,169 @@
+# encoding: UTF-8
+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

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 
 require 'gooddata/models/domain'
+require 'gooddata/helpers/csv_helper'
 
 describe GoodData::Domain do
   before(:each) do
@@ -97,19 +98,27 @@ describe GoodData::Domain do
     end
 
     it 'Update a user' do
-      user = @domain.users.sample
+      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
@@ -121,13 +130,15 @@ describe GoodData::Domain do
     end
 
     it 'updates properties of a profile' do
+      pending 'Add more users'
+
       user = @domain.users
         .reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }.sample
 
       old_email = user.email
       old_sso_provider = user.sso_provider || ''
       user.email = 'john.doe@gooddata.com'
-      user.sso_provider = user.sso_provider ? user.sso_provider.reverse : 'some_sso_provider'
+      user.sso_provider = user.sso_provider.blank? ? user.sso_provider.reverse : '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'

data/spec/unit/models/from_wire_spec.rb

@@ -11,125 +11,304 @@ describe GoodData::Model::FromWire do
     @blueprint = FromWire.from_wire(@model_view)
   end
 
-  it "should parse the model view and return the blueprint" do
-    expect(@blueprint.datasets.count).to eq 28
-  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,
+        },
+        {
+          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 have a datatype if defined" do
-    col = @blueprint.find_dataset('stage_history').find_column_by_name('stage_duration', nil)
-    expect(col.key?(:gd_data_type)).to eq true
-    expect(col[:gd_data_type]).to eq 'DECIMAL(12,2)'
+    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
 
-  it "should have a datatype if defined" do
-    col = @blueprint.find_dataset('stage_history').find_column_by_name('currentstatus', nil)
-    expect(col.key?(:gd_type)).to eq true
-    expect(col[:gd_type]).to eq 'GDC.text'
-  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 validate a gd_datatype" do
-    expect(GoodData::Model.check_gd_datatype("GDC.time")).to eq true
-    expect(GoodData::Model.check_gd_datatype("gdc.time")).to eq false
-    expect(GoodData::Model.check_gd_datatype("gdc.time3")).to eq false
-  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"
+        },
+        {
+          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 omit titles if they are superfluous" do
-    view = MultiJson.load(File.read('./spec/data/superfluous_titles_view.json'))
-    blueprint = FromWire.from_wire(view)
-    expect(blueprint.datasets.count).to eq 1
-    expect(blueprint.datasets.first.find_column_by_name('current_status', nil).key?(:title)).to eq false
-    expect(blueprint.datasets.mapcat { |ds| ds.columns }.any? {|col| col[:name].titleize == col[:title]}).to eq false
+    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
 
-  it "should enable sorting" do
-    skip("UAAA")
+  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
+
+    it 'should' do
+      skip('primary vs default. Is it covered?')
+    end
   end
 
-  it "should allow defining date dimensions" do
-    skip('UAAA')
+  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
 
-  it "should generate the same thing it parsed" do
-    a = @model_view['projectModelView']['model']['projectModel']['datasets'][3]
-    b = @blueprint.to_wire
-    # expect(b).to eq a
+  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
 
-  it "should be able to parse the anchor out of dataset" do
-    x = FromWire.parse_anchor(@model_view['projectModelView']['model']['projectModel']['datasets'][3])
-    expect(x).to eq [
-      {
-        type: 'anchor',
-        name: "techoppanalysis",
-        folder: "Opportunity Benchmark",
-        title: "Tech Opp. Analysis",
-        gd_data_type: "VARCHAR(128)",
-        gd_type: "GDC.text",
-        default_label: true
-      }]
+  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'))
+      bp = GoodData::Model::FromWire.from_wire(model_view)
+    end
   end
 
-  it "should be able to parse the anchor out of dataset" do
-    x = FromWire.parse_attributes(@model_view['projectModelView']['model']['projectModel']['datasets'][3])
-    expect(x).to eq [
-      {
-        :type=>'attribute',
-        :folder => "Opportunity Benchmark",
-        :name=>"month",
-        :gd_data_type=>"VARCHAR(128)",
-        :gd_type=>"GDC.text",
-        :default_label=>true
-      },
-     {
-       :type=>'label',
-       :reference=>"month",
-       :name=>"monthsortingnew",
-       :title=>"MonthSortingNew",
-       :gd_data_type=>"INT",
-       :gd_type=>"GDC.text"
-      },
-     {
-       :type=>'attribute',
-       :folder => "Opportunity Benchmark",
-       :name=>"cohorttype",
-       :title=>"Cohort Type",
-       :gd_data_type=>"VARCHAR(128)",
-       :gd_type=>"GDC.text",
-       :default_label=>true
-      }]
+  it "should parse the model view and return the blueprint" do
+    expect(@blueprint.datasets.count).to eq 28
   end
 
-  it "should be able to parse the anchor out of dataset when there are multiple labels and primary label and default label are not the same" do
-    x = FromWire.parse_anchor(@model_view['projectModelView']['model']['projectModel']['datasets'][7])
-    expect(x).to eq [
-      {
-        :type=>"anchor",
-        :name=>"factsof",
-        :title=>"Records of opp_records",
-        :gd_data_type=>"VARCHAR(128)",
-        :gd_type=>"GDC.text"
-      },
-      {
-        :type=>"label",
-        :reference=>"factsof",
-        :name=>"opp_records_conctn_point",
-        :title=>"opp_records_conctn_point",
-        :gd_data_type=>"VARCHAR(128)",
-        :gd_type=>"GDC.text",
-        :default_label => true
-      }]
+  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 be able to parse description from both attributes and facts" do
-    expect(@blueprint.find_dataset('opportunity').anchor[:description]).to eq 'This is opportunity attribute description'
-    expect(@blueprint.find_dataset('stage_history').facts.find {|f| f[:name] == 'stage_velocity'}[:description]).to eq 'Velocity description'
-    expect(@blueprint.find_dataset('opp_owner').attributes.find {|f| f[:name] == 'region'}[:description]).to eq 'Owner Region description'
+  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 be able to deal with fiscal dimensions with weird names" do
-    model_view = MultiJson.load(File.read('./spec/data/wire_models/nu_model.json'))
-    blueprint = FromWire.from_wire(model_view)
-    blueprint.lint
+  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 omit titles if they are superfluous" do
+  #   view = MultiJson.load(File.read('./spec/data/superfluous_titles_view.json'))
+  #   blueprint = FromWire.from_wire(view)
+  #   expect(blueprint.datasets.count).to eq 1
+  #   expect(blueprint.datasets.first.find_column_by_name('current_status', nil).key?(:title)).to eq false
+  #   expect(blueprint.datasets.mapcat { |ds| ds.columns }.any? {|col| col[:name].titleize == col[:title]}).to eq false
+  # end
+  #
+  # it "should enable sorting" do
+  #   skip("UAAA")
+  # end
+  #
+  # it "should generate the same thing it parsed" do
+  #   a = @model_view['projectModelView']['model']['projectModel']['datasets'][3]
+  #   b = @blueprint.to_wire
+  #   # expect(b).to eq a
+  # 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