active_hash_relation 1.1.0 → 1.2.0

data/spec/tests/associations/has_one_spec.rb

@@ -0,0 +1,89 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'associations' do
+    context 'has_one' do
+      it "one where clause" do
+        hash = {address: {street: 'Sveavägen 4' }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN addresses ON addresses.user_id = users.id",
+          "WHERE (addresses.street = 'Sveavägen 4')"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "multiple where clause" do
+        hash = {address: {street: 'Sveavägen 4', country: 'SE' }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN addresses ON addresses.user_id = users.id",
+          "WHERE (addresses.street = 'Sveavägen 4')",
+          "AND (addresses.country = 'SE')"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "multiple queries" do
+        hash = {address: {street: {like: 'sveav', with_ilike: true}, city: {starts_with: 'New'} }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN addresses ON addresses.user_id = users.id",
+          "WHERE (addresses.street ILIKE '%sveav%')",
+          "AND (addresses.city LIKE 'New%')"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "scope" do
+        hash = {address: {scopes: {in_sweden: true} }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN addresses ON addresses.user_id = users.id",
+          "WHERE addresses.country = 'SE'"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "null" do
+        hash = {address: {street: {null: false} }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN addresses ON addresses.user_id = users.id",
+          "WHERE (addresses.street IS NOT NULL)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "sorting" do
+        hash = {address: {street: {like: 'svea'}, sort: {property: :street, order: :asc} }}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN addresses ON addresses.user_id = users.id",
+          "WHERE (addresses.street LIKE '%svea%')",
+          "ORDER BY addresses.street ASC"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+    end
+  end
+end
+

data/spec/tests/booleans_spec.rb

@@ -0,0 +1,29 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'booleans' do
+    it "one boolean where clause" do
+      hash = {admin: false}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users",
+        "WHERE users.admin = 'f'"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    it "multi boolean where clauses" do
+      hash = {admin: false, verified: true}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users",
+        "WHERE users.admin = 'f' AND users.verified = 't'"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+  end
+end

data/spec/tests/limit_spec.rb

@@ -0,0 +1,30 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'limit' do
+    it "one where clause" do
+      hash = {microposts_count: 10, limit: 10}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users WHERE (users.microposts_count = 10) LIMIT 10"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    it "multiple where clause" do
+      hash = {microposts_count: 3, followers_count: 5, limit: 10}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users",
+        "WHERE (users.microposts_count = 3)",
+        "AND (users.followers_count = 5)",
+        "LIMIT 10"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+  end
+end

data/spec/tests/null_spec.rb

@@ -0,0 +1,44 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'NULL' do
+    context "one where clause" do
+      it "is null" do
+        hash = {admin: {null: true}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "WHERE (users.admin IS NULL)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "is not null" do
+        hash = {admin: {null: false}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "WHERE (users.admin IS NOT NULL)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+    end
+
+    it "multi where clauses" do
+      hash = {admin: {null: true}, verified: {null: false}}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users",
+        "WHERE (users.admin IS NULL)",
+        "AND (users.verified IS NOT NULL)"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+  end
+end

data/spec/tests/numbers_spec.rb

@@ -0,0 +1,142 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'numbers' do
+    it "one where clause" do
+      hash = {microposts_count: 10}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users WHERE (users.microposts_count = 10)"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    it "multiple where clause" do
+      hash = {microposts_count: 3, followers_count: 5}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users",
+        "WHERE (users.microposts_count = 3)",
+        "AND (users.followers_count = 5)"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    it "multiple values" do
+      hash = {microposts_count: [3,4,5]}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users",
+        "WHERE (users.microposts_count IN (3, 4, 5))",
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    context "queries" do
+      it 'eq' do
+        hash = {microposts_count: {eq: 10}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users WHERE (users.microposts_count = 10)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it 'le' do
+        hash = {microposts_count: {le: 10}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users WHERE (users.microposts_count < 10)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it 'leq' do
+        hash = {microposts_count: {leq: 10}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users WHERE (users.microposts_count <= 10)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it 'ge' do
+        hash = {microposts_count: {ge: 10}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users WHERE (users.microposts_count > 10)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it 'geq' do
+        hash = {microposts_count: {geq: 10}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users WHERE (users.microposts_count >= 10)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      context 'combined' do
+        it 'with a single column' do
+          hash = {microposts_count: {geq: 10, le: 20}}
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count < 20)",
+            "AND (users.microposts_count >= 10)"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+
+        it 'with multiple columns' do
+          hash = {
+            microposts_count: {geq: 10, le: 20},
+            followers_count: {leq: 50, ge: 0}
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count < 20)",
+            "AND (users.microposts_count >= 10)",
+            "AND (users.followers_count <= 50)",
+            "AND (users.followers_count > 0)"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+      end
+
+      it 'rails enum' do
+        hash = {status: 0}
+
+        query = HelperClass.new.apply_filters(Micropost.all, hash).to_sql
+        expected_query = q(
+          "SELECT microposts.* FROM microposts WHERE (microposts.status = 0)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+    end
+  end
+end

data/spec/tests/or_filter_spec.rb

@@ -0,0 +1,98 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  if ActiveRecord::VERSION::MAJOR < 5
+    context 'OR filter' do
+      it "one OR clause" do
+        logger = double('logger')
+        allow(logger).to receive(:warn)
+        allow(Rails).to receive(:logger).and_return(logger)
+
+        hash = {or: [{name: 'Filippos'}, {name: 'Vasilis'}]}
+
+        HelperClass.new.apply_filters(User.all, hash).to_sql
+        expect(logger).to have_received(:warn)
+      end
+    end
+
+  else
+    context 'OR filter' do
+      it "one OR clause" do
+        hash = {or: [{name: 'Filippos'}, {name: 'Vasilis'}]}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "WHERE ((users.name = 'Filippos') OR (users.name = 'Vasilis'))"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "multiple OR clauses" do
+        hash = {or: [{or: [{name: 'Filippos'}, {name: 'Vasilis'}]}, {or: [{id: 1}, {id: 2}]}]}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "WHERE",
+          "(",
+          "((users.name = 'Filippos') OR (users.name = 'Vasilis'))",
+          "OR",
+          "((users.id = 1) OR (users.id = 2))",
+          ")"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "one complex OR clause" do
+        hash = {or: [{name: 'Filippos', token: '123'}, {name: 'Vasilis'}]}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "WHERE",
+          "(",
+            "(users.name = 'Filippos') AND (users.token = '123')",
+            "OR",
+            "(users.name = 'Vasilis')",
+          ")"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "nested OR clause" do
+        hash = {or: [{or: [{name: 'Filippos'}, {token: '123'}]}, {name: 'Vasilis'}]}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "WHERE",
+          "(",
+            "((users.name = 'Filippos') OR (users.token = '123'))",
+            "OR",
+            "(users.name = 'Vasilis')",
+          ")"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "OR clause on associations" do
+          hash = {microposts: {or: [{content: 'Sveavägen 4'}, {id: 1}]}}
+
+          query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "INNER JOIN microposts ON microposts.user_id = users.id",
+            "WHERE ((microposts.content = 'Sveavägen 4') OR (microposts.id = 1))"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+      end
+    end
+  end
+end
+

data/spec/tests/primary_key_spec.rb

@@ -0,0 +1,29 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'primary_key' do
+    it "one key" do
+      hash = {id: 1}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users WHERE (users.id = 1)"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    it "multiple keys" do
+      hash = {id: [1,2,3,4]}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users WHERE (users.id IN (1, 2, 3, 4))"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+  end
+end
+
+