dbee 2.1.1 → 3.0.0

data/spec/dbee/query/filters_spec.rb

@@ -9,24 +9,23 @@
 
 require 'spec_helper'
 
-describe Dbee::Query::Filters do
-  FILTERS_CONFIG = { key_path: 'a.b.c', value: :d }.freeze
-
-  FILTER_FACTORIES = {
-    Dbee::Query::Filters::Contains => FILTERS_CONFIG.merge(type: :contains),
-    Dbee::Query::Filters::Equals => FILTERS_CONFIG.merge(type: :equals),
-    Dbee::Query::Filters::GreaterThanOrEqualTo => FILTERS_CONFIG.merge(
-      type: :greater_than_or_equal_to
-    ),
-    Dbee::Query::Filters::GreaterThan => FILTERS_CONFIG.merge(type: :greater_than),
-    Dbee::Query::Filters::LessThanOrEqualTo => FILTERS_CONFIG.merge(type: :less_than_or_equal_to),
-    Dbee::Query::Filters::LessThan => FILTERS_CONFIG.merge(type: :less_than),
-    Dbee::Query::Filters::NotContain => FILTERS_CONFIG.merge(type: :not_contain),
-    Dbee::Query::Filters::NotEquals => FILTERS_CONFIG.merge(type: :not_equals),
-    Dbee::Query::Filters::NotStartWith => FILTERS_CONFIG.merge(type: :not_start_with),
-    Dbee::Query::Filters::StartsWith => FILTERS_CONFIG.merge(type: :starts_with)
-  }.freeze
+FILTERS_CONFIG = { key_path: 'a.b.c', value: :d }.freeze
+FILTER_FACTORIES = {
+  Dbee::Query::Filters::Contains => FILTERS_CONFIG.merge(type: :contains),
+  Dbee::Query::Filters::Equals => FILTERS_CONFIG.merge(type: :equals),
+  Dbee::Query::Filters::GreaterThanOrEqualTo => FILTERS_CONFIG.merge(
+    type: :greater_than_or_equal_to
+  ),
+  Dbee::Query::Filters::GreaterThan => FILTERS_CONFIG.merge(type: :greater_than),
+  Dbee::Query::Filters::LessThanOrEqualTo => FILTERS_CONFIG.merge(type: :less_than_or_equal_to),
+  Dbee::Query::Filters::LessThan => FILTERS_CONFIG.merge(type: :less_than),
+  Dbee::Query::Filters::NotContain => FILTERS_CONFIG.merge(type: :not_contain),
+  Dbee::Query::Filters::NotEquals => FILTERS_CONFIG.merge(type: :not_equals),
+  Dbee::Query::Filters::NotStartWith => FILTERS_CONFIG.merge(type: :not_start_with),
+  Dbee::Query::Filters::StartsWith => FILTERS_CONFIG.merge(type: :starts_with)
+}.freeze
 
+describe Dbee::Query::Filters do
   FILTER_FACTORIES.each_pair do |constant, config|
     it "should instantiate #{constant} objects" do
       expect(described_class.make(config)).to be_a(constant)

data/spec/dbee/query_spec.rb

@@ -9,9 +9,63 @@
 
 require 'spec_helper'
 
+README_EXAMPLES = {
+  'Get all practices' => {
+    fields: [
+      { key_path: 'id' },
+      { key_path: 'active' },
+      { key_path: 'name' }
+    ]
+  },
+  'Get all practices, limit to 10, and sort by name (descending) then id (ascending)' => {
+    fields: [
+      { key_path: 'id' },
+      { key_path: 'active' },
+      { key_path: 'name' }
+    ],
+    sorters: [
+      { key_path: 'name', direction: :descending },
+      { key_path: 'id' }
+    ],
+    limit: 10
+  },
+  "Get top 5 active practices and patient whose name start with 'Sm':" => {
+    fields: [
+      { key_path: 'name', display: 'Practice Name' },
+      { key_path: 'patients.first', display: 'Patient First Name' },
+      { key_path: 'patients.middle', display: 'Patient Middle Name' },
+      { key_path: 'patients.last', display: 'Patient Last Name' }
+    ],
+    filters: [
+      { type: :equals, key_path: 'active', value: true },
+      { type: :starts_with, key_path: 'patients.last', value: 'Sm' }
+    ],
+    limit: 5
+  },
+  'Get practice IDs, patient IDs, names, and cell phone numbers that starts with 555' => {
+    fields: [
+      { key_path: 'id', display: 'Practice ID #' },
+      { key_path: 'patients.id', display: 'Patient ID #' },
+      { key_path: 'patients.first', display: 'Patient First Name' },
+      { key_path: 'patients.middle', display: 'Patient Middle Name' },
+      { key_path: 'patients.last', display: 'Patient Last Name' },
+      { key_path: 'patients.cell_phone_numbers.phone_number', display: 'Patient Cell #' }
+    ],
+    filters: [
+      { type: :equals, key_path: 'active', value: true },
+      {
+        type: :starts_with,
+        key_path: 'patients.cell_phone_numbers.phone_number',
+        value: '555'
+      }
+    ]
+  }
+}.freeze
+
 describe Dbee::Query do
   let(:config) do
     {
+      from: 'my_model',
       fields: [
         { key_path: 'matt.nick.sam', display: 'some display' },
         { key_path: 'katie' },
@@ -116,60 +170,7 @@ describe Dbee::Query do
   end
 
   context 'README examples' do
-    EXAMPLES = {
-      'Get all practices' => {
-        fields: [
-          { key_path: 'id' },
-          { key_path: 'active' },
-          { key_path: 'name' }
-        ]
-      },
-      'Get all practices, limit to 10, and sort by name (descending) then id (ascending)' => {
-        fields: [
-          { key_path: 'id' },
-          { key_path: 'active' },
-          { key_path: 'name' }
-        ],
-        sorters: [
-          { key_path: 'name', direction: :descending },
-          { key_path: 'id' }
-        ],
-        limit: 10
-      },
-      "Get top 5 active practices and patient whose name start with 'Sm':" => {
-        fields: [
-          { key_path: 'name', display: 'Practice Name' },
-          { key_path: 'patients.first', display: 'Patient First Name' },
-          { key_path: 'patients.middle', display: 'Patient Middle Name' },
-          { key_path: 'patients.last', display: 'Patient Last Name' }
-        ],
-        filters: [
-          { type: :equals, key_path: 'active', value: true },
-          { type: :starts_with, key_path: 'patients.last', value: 'Sm' }
-        ],
-        limit: 5
-      },
-      'Get practice IDs, patient IDs, names, and cell phone numbers that starts with 555' => {
-        fields: [
-          { key_path: 'id', display: 'Practice ID #' },
-          { key_path: 'patients.id', display: 'Patient ID #' },
-          { key_path: 'patients.first', display: 'Patient First Name' },
-          { key_path: 'patients.middle', display: 'Patient Middle Name' },
-          { key_path: 'patients.last', display: 'Patient Last Name' },
-          { key_path: 'patients.cell_phone_numbers.phone_number', display: 'Patient Cell #' }
-        ],
-        filters: [
-          { type: :equals, key_path: 'active', value: true },
-          {
-            type: :starts_with,
-            key_path: 'patients.cell_phone_numbers.phone_number',
-            value: '555'
-          }
-        ]
-      }
-    }.freeze
-
-    EXAMPLES.each_pair do |name, query|
+    README_EXAMPLES.each_pair do |name, query|
       specify name do
         expect(described_class.make(query)).to be_a(described_class)
       end

data/spec/dbee/schema_creator_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+require 'fixtures/models'
+
+describe Dbee::SchemaCreator do
+  let(:model_hash_graph) do
+    {
+      'model1' => {
+        relationships: {
+          model2: {
+            constraints: [
+              {
+                type: 'reference',
+                parent: 'id',
+                name: 'model1_id'
+              }
+            ]
+          }
+        }
+      },
+      'model2' => nil
+    }
+  end
+  let(:schema) { Dbee::Schema.new(model_hash_graph) }
+
+  let(:model_hash_tree) do
+    {
+      name: 'model1',
+      models: [
+        {
+          name: 'model2',
+          constraints: [
+            {
+              type: 'reference',
+              parent: 'id',
+              name: 'model1_id'
+            }
+          ]
+        }
+      ]
+    }
+  end
+
+  let(:model_tree) { Dbee::Model.make(model_hash_tree) }
+
+  let(:query_hash) do
+    {
+      from: 'model1',
+      fields: [
+        { key_path: :a }
+      ]
+    }
+  end
+  let(:query) { Dbee::Query.make(query_hash) }
+
+  let(:query_hash_no_from) { query_hash.slice(:fields) }
+  let(:query_no_from) { Dbee::Query.make(query_hash_no_from) }
+
+  describe 'query parsing' do
+    it 'passes through Dbee::Query instances' do
+      expect(described_class.new(schema, query).query).to eq query
+    end
+
+    it 'creates a Dbee::Query from a query hash' do
+      expect(described_class.new(schema, query_hash).query).to eq query
+    end
+
+    describe 'the "from" field' do
+      it 'raises an error when nil' do
+        expect do
+          described_class.new(schema, query_hash_no_from)
+        end.to raise_error(ArgumentError, 'query requires a from model name')
+      end
+
+      it 'raises an error when the empty string' do
+        expect do
+          described_class.new(schema, query_hash_no_from.merge(from: ''))
+        end.to raise_error(ArgumentError, 'query requires a from model name')
+      end
+    end
+  end
+
+  describe 'tree based models' do
+    it 'creates a schema from a Dbee::Model' do
+      expect(described_class.new(model_tree, query).schema).to eq schema
+    end
+
+    describe 'hash detection' do
+      it 'creates a schema from a hash model' do
+        expect(described_class.new(model_hash_tree, query).schema).to eq schema
+      end
+
+      it 'creates a schema from a minimal hash model with no child models' do
+        minimal_tree_hash = { name: :practice }
+        minimal_schema =  Dbee::Schema.new(practice: nil)
+
+        expect(described_class.new(minimal_tree_hash, {}).schema).to eq minimal_schema
+      end
+    end
+
+    describe 'query "from" field' do
+      it 'is set using name of the root model of the tree' do
+        expect(described_class.new(model_tree, query_no_from).query).to eq query
+      end
+
+      it 'raises an error the query "from" does not equal the root model name' do
+        query_hash_different_from = query_hash_no_from.merge(from: :bogus_model)
+
+        expect do
+          described_class.new(model_tree, query_hash_different_from)
+        end.to raise_error(
+          ArgumentError,
+          "expected from model to be 'model1' but got 'bogus_model'"
+        )
+      end
+    end
+  end
+
+  describe 'graph based models' do
+    it 'creates a schema from a hash schema' do
+      expect(described_class.new(model_hash_graph, query).schema).to eq schema
+    end
+
+    it 'passes through Dbee::Schema instances' do
+      expect(described_class.new(schema, query).schema).to eq schema
+    end
+
+    describe 'when given a Dbee::Base class' do
+      let(:dsl_model_class) { PartitionerExamples::Dog }
+
+      it 'creates a schema' do
+        expected_config = yaml_fixture('models.yaml')['Partitioner Example 1']
+        expected_schema = Dbee::Schema.new(expected_config)
+        dog_query = Dbee::Query.make(query_hash_no_from.merge(from: :dog))
+
+        expect(described_class.new(dsl_model_class, dog_query).schema).to eq expected_schema
+      end
+
+      it "can infer the query's 'from' field" do
+        expect(described_class.new(dsl_model_class, query_no_from).query.from).to eq 'dog'
+      end
+
+      it 'raises an error the query "from" does not equal the DSL model name' do
+        cat_query = Dbee::Query.make(query_hash_no_from.merge(from: :cat))
+
+        expect do
+          described_class.new(dsl_model_class, cat_query)
+        end.to raise_error(
+          ArgumentError,
+          "expected from model to be 'dog' but got 'cat'"
+        )
+      end
+    end
+  end
+end

data/spec/dbee/schema_from_tree_based_model_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+require 'fixtures/models'
+
+describe Dbee::SchemaFromTreeBasedModel do
+  let(:tree_config) do
+    Dbee::Model.make(yaml_fixture('models.yaml')['Theaters, Members, and Movies Tree Based'])
+  end
+  let(:schema_config) do
+    yaml_fixture('models.yaml')['Theaters, Members, and Movies from Tree']
+  end
+
+  it 'converts the theaters model' do
+    expected_schema = Dbee::Schema.new(schema_config)
+    expect(described_class.convert(tree_config)).to eq expected_schema
+  end
+
+  it 'does not raise any errors when converting the readme model' do
+    tree_config = Dbee::Model.make(yaml_fixture('models.yaml')['Readme Tree Based'])
+
+    expect { described_class.convert(tree_config) }.not_to raise_error
+  end
+end

data/spec/dbee/schema_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+require_relative '../fixtures/models'
+
+describe Dbee::Schema do
+  def make_model(model_name)
+    raise "no model named '#{model_name}'" unless schema_config.key?(model_name)
+
+    Dbee::Model.make((schema_config[model_name] || {}).merge('name' => model_name))
+  end
+
+  let(:model_name) do
+    'Theaters, Members, and Movies from DSL'
+  end
+  let(:schema_config) { yaml_fixture('models.yaml')[model_name] }
+
+  let(:demographics_model) { make_model('demographic') }
+  let(:members_model) { make_model('member') }
+  let(:movies_model) { make_model('movie') }
+  let(:phone_numbers_model) { make_model('phone_number') }
+  let(:theaters_model) { make_model('theater') }
+
+  let(:subject) { described_class.new(schema_config) }
+
+  describe '#expand_query_path' do
+    specify 'one model case' do
+      expect(subject.expand_query_path(members_model, Dbee::KeyPath.new('id'))).to eq []
+    end
+
+    specify 'two model case' do
+      expected_path = [[members_model.relationship_for_name('movies'), movies_model]]
+      expect(
+        subject.expand_query_path(members_model, Dbee::KeyPath.new('movies.id'))
+      ).to eq expected_path
+    end
+
+    it 'traverses aliased models' do
+      expected_path = [
+        [members_model.relationship_for_name('demos'), demographics_model],
+        [demographics_model.relationship_for_name('phone_numbers'), phone_numbers_model]
+      ]
+
+      expect(
+        subject.expand_query_path(members_model, Dbee::KeyPath.new('demos.phone_numbers.id'))
+      ).to eq expected_path
+    end
+
+    it 'raises an error given an unknown relationship' do
+      expect do
+        subject.expand_query_path(theaters_model, Dbee::KeyPath.new('demographics.id'))
+      end.to raise_error("model 'theater' does not have a 'demographics' relationship")
+    end
+  end
+end

data/spec/dbee_spec.rb

@@ -13,59 +13,39 @@ require 'fixtures/models'
 describe Dbee do
   describe '#sql' do
     let(:provider) { Dbee::Providers::NullProvider.new }
-
-    let(:model_hash) do
-      {
-        name: 'something'
-      }
-    end
-
-    let(:model) { Dbee::Model.make(model_hash) }
-
     let(:query_hash) do
       {
+        from: 'my_model',
         fields: [
           { key_path: :a }
         ]
       }
     end
-
     let(:query) { Dbee::Query.make(query_hash) }
+    let(:schema) { Dbee::Schema.new({}) }
 
-    it 'accepts a hash as a model and passes a Model instance to provider#sql' do
-      expect(provider).to receive(:sql).with(model, query)
-
-      described_class.sql(model_hash, query, provider)
-    end
-
-    it 'accepts a Dbee::Model instance as a model and passes a Model instance to provider#sql' do
-      expect(provider).to receive(:sql).with(model, query)
+    it 'accepts a query hash and a Schema and passes them into provider#sql' do
+      expect(provider).to receive(:sql).with(schema, query)
 
-      described_class.sql(model, query, provider)
+      described_class.sql(schema, query_hash, provider)
     end
 
-    it 'accepts a Dbee::Base constant as a model and passes a Model instance to provider#sql' do
-      model_constant = Models::Theater
-
-      expect(provider).to receive(:sql).with(model_constant.to_model(query.key_chain), query)
-
-      described_class.sql(model_constant, query, provider)
+    it 'does not allow a nil schema' do
+      expect do
+        described_class.sql(nil, query, provider)
+      end.to raise_error ArgumentError, /schema or model is required/
     end
 
-    it 'accepts a Dbee::Query instance as a query and passes a Query instance to provider#sql' do
-      model = Models::Theater.to_model(query.key_chain)
-
-      expect(provider).to receive(:sql).with(model, query)
-
-      described_class.sql(model, query, provider)
+    it 'does not allow a nil query' do
+      expect do
+        described_class.sql(schema, nil, provider)
+      end.to raise_error ArgumentError, /query is required/
     end
 
-    it 'accepts a hash as a query and passes a Query instance to provider#sql' do
-      model = Models::Theater.to_model(query.key_chain)
-
-      expect(provider).to receive(:sql).with(model, query)
-
-      described_class.sql(model, query_hash, provider)
+    it 'does not allow a nil provider' do
+      expect do
+        described_class.sql(schema, query, nil)
+      end.to raise_error ArgumentError, /provider is required/
     end
   end
 end