dbee 2.0.2 → 3.0.0

data/spec/dbee/query/field_spec.rb

@@ -10,6 +10,31 @@
 require 'spec_helper'
 
 describe Dbee::Query::Field do
+  let(:config) do
+    {
+      display: 'd',
+      key_path: 'a.b.c'
+    }
+  end
+
+  let(:config_with_aggregation_and_filters) do
+    config.merge(
+      aggregator: :ave,
+      filters: [
+        {
+          key_path: 'a.b',
+          value: 'something'
+        }
+      ]
+    )
+  end
+
+  subject { described_class.new(config_with_aggregation_and_filters) }
+
+  let(:subject_without_aggregation_and_filters) do
+    described_class.new(config)
+  end
+
   it 'should act as hashable' do
     expect(described_class).to respond_to(:make)
     expect(described_class).to respond_to(:array)
@@ -24,16 +49,19 @@ describe Dbee::Query::Field do
   end
 
   context 'equality' do
-    let(:config) { { key_path: 'a.b.c', display: 'd' } }
+    specify '#hash produces same output as [aggregator, key_path, and display]' do
+      expected = [
+        subject.aggregator,
+        subject.display,
+        subject.filters,
+        subject.key_path
+      ].hash
 
-    subject { described_class.new(config) }
-
-    specify '#hash produces same output as concatenated string hash of key_path and display' do
-      expect(subject.hash).to eq("#{config[:key_path]}#{config[:display]}".hash)
+      expect(subject.hash).to eq(expected)
     end
 
     specify '#== and #eql? compare attributes' do
-      object2 = described_class.new(config)
+      object2 = described_class.new(config_with_aggregation_and_filters)
 
       expect(subject).to eq(object2)
       expect(subject).to eql(object2)
@@ -44,4 +72,24 @@ describe Dbee::Query::Field do
       expect(subject).not_to eq(nil)
     end
   end
+
+  describe '#aggregator?' do
+    it 'returns true if not nil' do
+      expect(subject.aggregator?).to be true
+    end
+
+    it 'returns false if nil' do
+      expect(subject_without_aggregation_and_filters.aggregator?).to be false
+    end
+  end
+
+  describe '#filters?' do
+    it 'returns true if at least one filter' do
+      expect(subject.filters?).to be true
+    end
+
+    it 'returns false if nil' do
+      expect(subject_without_aggregation_and_filters.filters?).to be false
+    end
+  end
 end

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' },
@@ -36,14 +90,6 @@ describe Dbee::Query do
   end
 
   describe '#initialize' do
-    it 'should raise an ArgumentError if fields keyword is missing' do
-      expect { described_class.new }.to raise_error(ArgumentError)
-    end
-
-    it 'should raise a NoFieldsError if no fields were passed in' do
-      expect { described_class.new(fields: []) }.to raise_error(Dbee::Query::NoFieldsError)
-    end
-
     it 'should remove duplicate filters (keep first instance)' do
       query_hash = {
         fields: [
@@ -124,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