dbee 2.1.0.pre.alpha → 3.1.0

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

data/spec/fixtures/models.yaml

@@ -1,4 +1,4 @@
-Theaters, Members, and Movies:
+Theaters, Members, and Movies Tree Based:
   name: theater
   table: theaters
   models:
@@ -119,7 +119,217 @@ Theaters, Members, and Movies:
                 - type: static
                   name: genre
                   value: comedy
+
+# Note that since converting from the tree does not have as much context as
+# converting from the DSL, the resulting graph is a bit different.
+Theaters, Members, and Movies from Tree:
+  theater:
+    table: theaters
+    relationships:
+      members:
+        constraints:
+          - type: reference
+            parent: id
+            name: tid
+          - type: reference
+            parent: partition
+            name: partition
+      parent_theater:
+        constraints:
+          - type: reference
+            name: id
+            parent: parent_theater_id
+  members:
+    relationships:
+      demos:
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+      movies:
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+      favorite_comic_movies:
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+          - type: static
+            name: genre
+            value: comic
+      favorite_mystery_movies:
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+          - type: static
+            name: genre
+            value: mystery
+      favorite_comedy_movies:
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+          - type: static
+            name: genre
+            value: comedy
+  demos:
+    table: demographics
+    relationships:
+      phone_numbers:
+        constraints:
+          - type: reference
+            parent: id
+            name: demographic_id
+  phone_numbers:
+  movies:
+  favorite_comic_movies:
+    table: movies
+  favorite_mystery_movies:
+    table: movies
+  favorite_comedy_movies:
+    table: movies
+  parent_theater:
+    table: theaters
+    relationships:
+      members:
+        constraints:
+          - type: reference
+            parent: id
+            name: tid
+          - type: reference
+            parent: partition
+            name: partition
+
+Theaters, Members, and Movies from DSL:
+  theater:
+    table: theaters
+    relationships:
+      members:
+        model: member
+        constraints:
+          - type: reference
+            parent: id
+            name: tid
+          - type: reference
+            parent: partition
+            name: partition
+      parent_theater:
+        model: theater
+        constraints:
+          - type: reference
+            name: id
+            parent: parent_theater_id
+  member:
+    table: members
+    relationships:
+      movies:
+        model: movie
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+      demos:
+        model: demographic
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+      favorite_comic_movies:
+        model: movie
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+          - type: static
+            name: genre
+            value: comic
+      favorite_mystery_movies:
+        model: movie
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+          - type: static
+            name: genre
+            value: mystery
+      favorite_comedy_movies:
+        model: movie
+        constraints:
+          - type: reference
+            parent: id
+            name: member_id
+          - type: static
+            name: genre
+            value: comedy
+  demographic:
+    table: demographics
+    relationships:
+      phone_numbers:
+        model: phone_number
+        constraints:
+          - type: reference
+            parent: id
+            name: demographic_id
+  phone_number:
+    table: phone_numbers
+  movie:
+    table: movies
+
 Readme:
+  practice:
+    table: practices
+    relationships:
+      patients:
+        model: patient
+        constraints:
+          - type: reference
+            name: practice_id
+            parent: id
+  patient:
+    table: patients
+    relationships:
+      notes:
+        model: note
+        constraints:
+          - type: reference
+            name: patient_id
+            parent: id
+      work_phone_number:
+        model: phone_number
+        constraints:
+          - type: reference
+            name: patient_id
+            parent: id
+          - type: static
+            name: phone_number_type
+            value: work
+      cell_phone_number:
+        model: phone_number
+        constraints:
+          - type: reference
+            name: patient_id
+            parent: id
+          - type: static
+            name: phone_number_type
+            value: cell
+      fax_phone_number:
+        model: phone_number
+        constraints:
+          - type: reference
+            name: patient_id
+            parent: id
+          - type: static
+            name: phone_number_type
+            value: fax
+  note:
+    table: notes
+  phone_number:
+    table: phones
+
+Readme Tree Based:
   name: practice
   table: practices
   models:
@@ -161,63 +371,51 @@ Readme:
             - type: static
               name: phone_number_type
               value: fax
+
 Cycle Example:
-  name: a
-  table: as
-  models:
-    - name: b1
-      table: bs
-      models:
-        - name: c
-          table: cs
-          models:
-            - name: a
-              table: as
-        - name: d
-          table: ds
-          models:
-            - name: a
-              table: as
-    - name: b2
-      table: bs
-      models:
-        - name: c
-          table: cs
-          models:
-            - name: a
-              table: as
-        - name: d
-          table: ds
-          models:
-            - name: a
-              table: as
-              models:
-                - name: b1
-                  table: bs
-                  models:
-                    - name: c
-                      table: cs
+  a:
+    table: as
+    relationships:
+      b1:
+        model: b
+      b2:
+        model: b
+  b:
+    table: bs
+    relationships:
+      c:
+      d:
+  c:
+    table: cs
+    relationships:
+      a:
+  d:
+    table: ds
+    relationships:
+      a:
 
 Partitioner Example 1:
-  name: dog
-  table: animals
-  partitioners:
-    - name: type
-      value: Dog
-    - name: deleted
-      value: false
+  dog:
+    table: animals
+    partitioners:
+      - name: type
+        value: Dog
+      - name: deleted
+        value: false
 
 Partitioner Example 2:
-  name: owner
-  table: owners
-  models:
-    - name: dogs
-      table: animals
-      constraints:
-        - name: owner_id
-          parent: id
-      partitioners:
-        - name: type
-          value: Dog
-        - name: deleted
-          value: false
+  owner:
+    table: owners
+    relationships:
+      dogs:
+        model: dog
+        constraints:
+          - name: owner_id
+            parent: id
+  dog:
+    table: animals
+    partitioners:
+      - name: type
+        value: Dog
+      - name: deleted
+        value: false

data/spec/spec_helper.rb

@@ -9,6 +9,13 @@
 
 require 'yaml'
 require 'pry'
+require 'pry-byebug'
+
+RSpec.configure do |config|
+  # Allow for disabling auto focus mode in certain environments like CI to
+  # prevent false positives when only a subset of the suite passes.
+  config.filter_run_when_matching :focus unless ENV['DISABLE_RSPEC_FOCUS'] == 'true'
+end
 
 unless ENV['DISABLE_SIMPLECOV'] == 'true'
   require 'simplecov'