forest_liana 3.0.0.pre.beta.10 → 3.0.0.pre.beta.11

data/spec/helpers/forest_liana/query_helper_spec.rb

@@ -0,0 +1,74 @@
+module ForestLiana
+  describe QueryHelper do
+    before(:all) do
+      Tree.connection
+      User.connection
+      Island.connection
+    end
+
+    describe 'get_one_associations' do
+      context 'on a model having 2 hasMany associations' do
+        it 'should not return any one-one associations' do
+          associations = QueryHelper.get_one_associations(User)
+          expect(associations.length).to eq(0)
+        end
+      end
+
+      context 'on a model having 3 belongsTo associations' do
+        it 'should return the one-one associations' do
+          associations = QueryHelper.get_one_associations(Tree)
+          expect(associations.length).to eq(3)
+          expect(associations.first.name).to eq(:owner)
+          expect(associations.first.klass).to eq(User)
+          expect(associations.second.name).to eq(:cutter)
+          expect(associations.second.klass).to eq(User)
+          expect(associations.third.name).to eq(:island)
+          expect(associations.third.klass).to eq(Island)
+        end
+      end
+    end
+
+    describe 'get_one_association_names_symbol' do
+      it 'should return the one-one associations names as symbols' do
+        expect(QueryHelper.get_one_association_names_symbol(Tree)).to eq([:owner, :cutter, :island])
+      end
+    end
+
+    describe 'get_one_association_names_string' do
+      it 'should return the one-one associations names as strings' do
+        expect(QueryHelper.get_one_association_names_string(Tree)).to eq(['owner', 'cutter', 'island'])
+      end
+    end
+
+    describe 'get_tables_associated_to_relations_name' do
+      context 'on a model having 2 hasMany associations' do
+        it 'should return an empty hash' do
+          tables_associated_to_relations_name =
+            QueryHelper.get_tables_associated_to_relations_name(User)
+          expect(tables_associated_to_relations_name.keys.length).to eq(0)
+        end
+      end
+
+      context 'on a model having 2 belongsTo associations' do
+        tables_associated_to_relations_name =
+          QueryHelper.get_tables_associated_to_relations_name(Tree)
+
+        it 'should return the one-one associations' do
+          expect(tables_associated_to_relations_name.keys.length).to eq(2)
+        end
+
+        it 'should return relationships having a name different than the targeted model' do
+          expect(tables_associated_to_relations_name['users'].length).to eq(2)
+          expect(tables_associated_to_relations_name['users'].first).to eq(:owner)
+          expect(tables_associated_to_relations_name['users'].second).to eq(:cutter)
+        end
+
+        it 'should return relationships on models having a custom table name' do
+          expect(tables_associated_to_relations_name['isle'].length).to eq(1)
+          expect(tables_associated_to_relations_name['isle'].first).to eq(:island)
+        end
+      end
+    end
+
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,61 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+require 'spec_helper'
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../dummy/config/environment', __FILE__)
+# Prevent database truncation if the environment is production
+abort("The Rails environment is running in production mode!") if Rails.env.production?
+require 'rspec/rails'
+# Add additional requires below this line. Rails is not loaded until this point!
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+#
+# Dir[Rails.root.join('spec', 'support', '**', '*.rb')].each { |f| require f }
+
+# Checks for pending migrations and applies them before tests are run.
+# If you are not using ActiveRecord, you can remove these lines.
+begin
+  ActiveRecord::Migration.maintain_test_schema!
+rescue ActiveRecord::PendingMigrationError => e
+  puts e.to_s.strip
+  exit 1
+end
+RSpec.configure do |config|
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, :type => :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+
+  # Filter lines from Rails gems in backtraces.
+  config.filter_rails_from_backtrace!
+  # arbitrary gems may also be filtered via:
+  # config.filter_gems_from_backtrace("gem name")
+end

data/spec/requests/resources_spec.rb

@@ -0,0 +1,97 @@
+require 'rails_helper'
+
+describe 'Requesting Tree resources', :type => :request  do
+  before(:each) do
+    user = User.create(name: 'Michel')
+    tree = Tree.create(name: 'Lemon Tree', owner: user, cutter: user)
+  end
+
+  after(:each) do
+    User.destroy_all
+    Tree.destroy_all
+  end
+
+  before(:each) do
+    allow(ForestLiana::IpWhitelist).to receive(:retrieve) { true }
+    allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
+    allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
+
+    allow_any_instance_of(ForestLiana::PermissionsChecker).to receive(:is_authorized?) { true }
+  end
+
+  headers = {
+    'Accept' => 'application/json',
+    'Content-Type' => 'application/json',
+    'Authorization' => 'Bearer eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxODQ5ODc4ODYzIiwiZGF0YSI6eyJpZCI6IjM4IiwidHlwZSI6InVzZXJzIiwiZGF0YSI6eyJlbWFpbCI6Im1pY2hhZWwua2Vsc29AdGhhdDcwLnNob3ciLCJmaXJzdF9uYW1lIjoiTWljaGFlbCIsImxhc3RfbmFtZSI6IktlbHNvIiwidGVhbXMiOiJPcGVyYXRpb25zIn0sInJlbGF0aW9uc2hpcHMiOnsicmVuZGVyaW5ncyI6eyJkYXRhIjpbeyJ0eXBlIjoicmVuZGVyaW5ncyIsImlkIjoxNn1dfX19fQ.U4Mxi0tq0Ce7y5FRXP47McNPRPhUx37LznQ5E3mJIp4'
+  }
+
+  describe 'index' do
+    describe 'without any filter' do
+      params = {
+        fields: { 'Tree' => 'id,name' },
+        page: { 'number' => '1', 'size' => '10' },
+        searchExtended: '0',
+        sort: '-id',
+        timezone: 'Europe/Paris'
+      }
+
+      it 'should respond 200' do
+        get '/forest/Tree', params, headers
+        expect(response.status).to eq(200)
+      end
+
+      it 'should respond the tree data' do
+        get '/forest/Tree', params, headers
+        expect(JSON.parse(response.body)).to eq({
+          "data" => [{
+            "type" => "Tree",
+            "id" => "1",
+            "attributes" => {
+              "id" => 1,
+              "name" => "Lemon Tree"
+            },
+            "links" => {
+              "self" => "/forest/tree/1"
+            }
+          }],
+          "included" => []
+        })
+      end
+    end
+
+    describe 'with a filter on an association that is not a displayed column' do
+      params = {
+        fields: { 'Tree' => 'id,name' },
+        filterType: 'and',
+        filter: { 'owner:id' => '$present' },
+        page: { 'number' => '1', 'size' => '10' },
+        searchExtended: '0',
+        sort: '-id',
+        timezone: 'Europe/Paris'
+      }
+
+      it 'should respond 200' do
+        get '/forest/Tree', params, headers
+        expect(response.status).to eq(200)
+      end
+
+      it 'should respond the tree data' do
+        get '/forest/Tree', params, headers
+        expect(JSON.parse(response.body)).to eq({
+          "data" => [{
+            "type" => "Tree",
+            "id" => "1",
+            "attributes" => {
+              "id" => 1,
+              "name" => "Lemon Tree"
+            },
+            "links" => {
+              "self" => "/forest/tree/1"
+            }
+          }],
+          "included" => []
+        })
+      end
+    end
+  end
+end

data/spec/services/forest_liana/apimap_sorter_spec.rb

@@ -0,0 +1,172 @@
+module ForestLiana
+  describe ApimapSorter do
+    describe 'apimap reordering' do
+      context 'on a disordered apimap' do
+        apimap = {
+          'meta': {
+            'orm_version': '4.34.9',
+            'liana_version': '1.5.24',
+            'database_type': 'postgresql',
+            liana: 'forest-rails',
+          },
+          'data': [{
+            id: 'users',
+            type: 'collections',
+            attributes: {
+              fields: [
+                { field: 'id', type: 'Number' },
+                { field: 'name', type: 'String' },
+                { field: 'firstName', type: 'String' },
+                { field: 'lastName', type: 'String' },
+                { field: 'email', type: 'String' },
+                { field: 'url', type: 'String' },
+                { field: 'createdAt', type: 'Date' },
+                { field: 'updatedAt', type: 'Date' },
+              ],
+              name: 'users',
+            }
+          }, {
+            id: 'guests',
+            type: 'collections',
+            attributes: {
+              fields: [
+                { field: 'id', type: 'Number' },
+                { field: 'email', type: 'String' },
+                { field: 'createdAt', type: 'Date' },
+                { field: 'updatedAt', type: 'Date' },
+              ],
+              name: 'guests',
+            }
+          }, {
+            type: 'collections',
+            id: 'animals',
+            attributes: {
+              fields: [
+                { 'is-sortable': false, field: 'id', 'is-filterable': false,  type: 'Number' },
+                { type: 'Date', field: 'createdAt' },
+                { field: 'updatedAt', type: 'Date' },
+              ],
+              name: 'animals',
+              integration: 'close.io',
+              'is-virtual': true,
+            }
+          }],
+          'included': [{
+            id: 'users.Women',
+            type: 'segments',
+            attributes: {
+              name: 'Women'
+            }
+          }, {
+            id: 'users.import',
+            type: 'actions',
+            links: {
+              self: '/actions'
+            },
+            attributes: {
+              name: 'import',
+              fields: [{
+                isRequired: true,
+                type: 'Boolean',
+                field: 'Save',
+                description: 'save the import file if true.',
+                defaultValue: 'true'
+              }, {
+                type: 'File',
+                field: 'File'
+              }],
+              'http-method': nil
+            }
+          }, {
+            attributes: {
+              name: 'Men'
+            },
+            id: 'users.Men',
+            type: 'segments'
+          }, {
+            id: 'animals.ban',
+            type: 'actions',
+            links: {
+              self: '/actions'
+            },
+            attributes: {
+              name: 'import',
+              global: true,
+              download: nil,
+              endpoint: nil,
+              redirect: nil,
+              'http-method': nil
+            }
+          }]
+        }
+
+        apimap = ActiveSupport::JSON.encode(apimap)
+        apimap = ActiveSupport::JSON.decode(apimap)
+        apimap_sorted = ApimapSorter.new(apimap).perform
+
+        it 'should sort the apimap sections' do
+          expect(apimap_sorted.keys).to eq(['data', 'included', 'meta'])
+        end
+
+        it 'should sort the data collections' do
+          expect(apimap_sorted['data'].map { |collection| collection['id'] }).to eq(
+            ['animals', 'guests', 'users'])
+        end
+
+        it 'should sort the data collection values' do
+          expect(apimap_sorted['data'][0].keys).to eq(['type', 'id', 'attributes'])
+          expect(apimap_sorted['data'][1].keys).to eq(['type', 'id', 'attributes'])
+          expect(apimap_sorted['data'][2].keys).to eq(['type', 'id', 'attributes'])
+        end
+
+        it 'should sort the data collections attributes values' do
+          expect(apimap_sorted['data'][0]['attributes'].keys).to eq(['name', 'integration', 'is-virtual', 'fields'])
+          expect(apimap_sorted['data'][1]['attributes'].keys).to eq(['name', 'fields'])
+          expect(apimap_sorted['data'][2]['attributes'].keys).to eq(['name', 'fields'])
+        end
+
+        it 'should sort the data collections attributes fields by name' do
+          expect(apimap_sorted['data'][0]['attributes']['fields'].map { |field| field['field'] }).to eq(['createdAt', 'id', 'updatedAt'])
+          expect(apimap_sorted['data'][1]['attributes']['fields'].map { |field| field['field'] }).to eq(['createdAt', 'email', 'id', 'updatedAt'])
+          expect(apimap_sorted['data'][2]['attributes']['fields'].map { |field| field['field'] }).to eq(['createdAt', 'email', 'firstName', 'id', 'lastName', 'name', 'updatedAt', 'url'])
+        end
+
+        it 'should sort the data collections attributes fields values' do
+          expect(apimap_sorted['data'][0]['attributes']['fields'][1].keys).to eq(['field', 'type', 'is-filterable', 'is-sortable'])
+        end
+
+        it 'should sort the included actions and segments objects' do
+          expect(apimap_sorted['included'].map { |object| object['id'] }).to eq(
+            ['animals.ban', 'users.import', 'users.Men', 'users.Women'])
+        end
+
+        it 'should sort the included actions and segments objects values' do
+          expect(apimap_sorted['included'][0].keys).to eq(['type', 'id', 'attributes', 'links'])
+          expect(apimap_sorted['included'][1].keys).to eq(['type', 'id', 'attributes', 'links'])
+          expect(apimap_sorted['included'][2].keys).to eq(['type', 'id', 'attributes'])
+          expect(apimap_sorted['included'][3].keys).to eq(['type', 'id', 'attributes'])
+        end
+
+        it 'should sort the included actions and segments objects attributes values' do
+          expect(apimap_sorted['included'][0]['attributes'].keys).to eq(['name', 'download', 'endpoint', 'global', 'http-method', 'redirect'])
+          expect(apimap_sorted['included'][1]['attributes'].keys).to eq(['name', 'http-method', 'fields'])
+          expect(apimap_sorted['included'][2]['attributes'].keys).to eq(['name'])
+          expect(apimap_sorted['included'][3]['attributes'].keys).to eq(['name'])
+        end
+
+        it 'should sort the included action attributes fields by name' do
+          expect(apimap_sorted['included'][1]['attributes']['fields'].map { |field| field['field'] }).to eq(['File', 'Save'])
+        end
+
+        it 'should sort the included action fields values' do
+          expect(apimap_sorted['included'][1]['attributes']['fields'][1].keys).to eq(['field', 'type', 'defaultValue', 'description', 'isRequired'])
+        end
+
+        it 'should sort the meta values' do
+          expect(apimap_sorted['meta'].keys).to eq(
+            ['database_type', 'liana', 'liana_version', 'orm_version'])
+        end
+      end
+    end
+  end
+end

data/spec/services/forest_liana/ip_whitelist_checker_spec.rb

@@ -0,0 +1,203 @@
+module ForestLiana
+  describe IpWhitelistChecker do
+    describe 'Check is_ip_matches_rule function' do
+      describe 'with IP "90.88.0.1" and "90.88.0.2"' do
+        it 'should return false' do
+          rule = {
+            'type' => 0,
+            'ip' => '90.88.0.1',
+          }
+
+          is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.0.2', rule)
+
+          expect(is_matching).to eq(false)
+        end
+      end
+
+      describe 'with IP "::1" and "aaaa"' do
+        it 'should raise an "ArgumentError" exception with "Unknown IP Address aaaa" message' do
+          rule = {
+            'type' => 0,
+            'ip' => '::1',
+          }
+
+          expect {
+            IpWhitelistChecker.is_ip_matches_rule('aaaa', rule)
+          }.to raise_error(ArgumentError, 'Unknown IP Address aaaa')
+        end
+      end
+
+      describe 'with IP "90.88.0.1" and "::1"' do
+        it 'should return false' do
+          rule = {
+            'type' => 0,
+            'ip' => '90.88.0.1',
+          }
+
+          is_matching = IpWhitelistChecker.is_ip_matches_rule('::1', rule)
+
+          expect(is_matching).to eq(false)
+        end
+      end
+
+      describe 'with IP "::1" and "::1"' do
+        it 'should return true' do
+          rule = {
+            'type' => 0,
+            'ip' => '::1',
+          }
+
+          is_matching = IpWhitelistChecker.is_ip_matches_rule('::1', rule)
+
+          expect(is_matching).to eq(true)
+        end
+      end
+
+      describe 'with IP "90.88.0.1" and "90.88.0.1"' do
+        it 'should return true' do
+          rule = {
+            'type' => 0,
+            'ip' => '90.88.0.1',
+          }
+
+          is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.0.1', rule)
+
+          expect(is_matching).to eq(true)
+        end
+      end
+
+      describe 'with IP "90.88.0.0" and "90.88.0.0"' do
+        it 'should return true' do
+          rule = {
+            'type' => 0,
+            'ip' => '90.88.0.0',
+          }
+
+          is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.0.0', rule)
+
+          expect(is_matching).to eq(true)
+        end
+      end
+
+      describe 'with IP "127.0.0.1" and "::1"' do
+        it 'should return true' do
+          rule = {
+            'type' => 0,
+            'ip' => '127.0.0.1',
+          }
+
+          is_matching = IpWhitelistChecker.is_ip_matches_rule('::1', rule)
+
+          expect(is_matching).to eq(true)
+        end
+      end
+
+      describe 'with range "90.88.0.0 - 90.88.255.255' do
+        rule = {
+          'type' => 1,
+          'ip_minimum' => '90.88.0.0',
+          'ip_maximum' => '90.88.255.255',
+        }
+
+        describe 'with IP "90.89.0.1"' do
+          it 'should return false' do
+            is_matching = IpWhitelistChecker.is_ip_matches_rule('90.89.0.1', rule)
+
+            expect(is_matching).to eq(false)
+          end
+        end
+
+        describe 'with IP "::ffff:90.89.0.1"' do
+          it 'should return false' do
+            is_matching = IpWhitelistChecker.is_ip_matches_rule('::ffff:90.89.0.1', rule)
+
+            expect(is_matching).to eq(false)
+          end
+        end
+
+        describe 'with IP "90.88.118.79"' do
+          it 'should return false' do
+            is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.118.79', rule)
+
+            expect(is_matching).to eq(true)
+          end
+        end
+      end
+
+      describe 'with range "90.88.0.1 - 90.88.255.255" and IP "90.88.118.79"' do
+        it 'should return true' do
+          rule = {
+            'type' => 1,
+            'ip_minimum' => '90.88.0.1',
+            'ip_maximum' => '90.88.255.255',
+          }
+
+          is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.118.79', rule)
+
+          expect(is_matching).to eq(true)
+        end
+      end
+
+      describe 'with range "90.88.0.1 - 90.88.254.254" and IP "90.88.118.79"' do
+        it 'should return true' do
+          rule = {
+            'type' => 1,
+            'ip_minimum' => '90.88.0.1',
+            'ip_maximum' => '90.88.254.254',
+          }
+
+          is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.118.79', rule)
+
+          expect(is_matching).to eq(true)
+        end
+      end
+
+      describe 'with subnet "90.88.0.0/24"' do
+        rule = {
+          'type' => 2,
+          'range' => '90.88.0.0/24',
+        }
+
+        describe 'with IP "90.88.0.1"' do
+          it 'should return true' do
+            is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.0.1', rule)
+
+            expect(is_matching).to eq(true)
+          end
+        end
+
+        describe 'with IP "90.88.0.0"' do
+          it 'should return true' do
+            is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.0.0', rule)
+
+            expect(is_matching).to eq(true)
+          end
+        end
+
+        describe 'with IP "90.88.0.254"' do
+          it 'should return true' do
+            is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.0.254', rule)
+
+            expect(is_matching).to eq(true)
+          end
+        end
+
+        describe 'with IP "90.88.1.1"' do
+          it 'should return true' do
+            is_matching = IpWhitelistChecker.is_ip_matches_rule('90.88.1.1', rule)
+
+            expect(is_matching).to eq(false)
+          end
+        end
+
+        describe 'with IP "::1"' do
+          it 'should return true' do
+            is_matching = IpWhitelistChecker.is_ip_matches_rule('::1', rule)
+
+            expect(is_matching).to eq(false)
+          end
+        end
+      end
+    end
+  end
+end