releaf-core 2.0.0 → 2.0.1

data/spec/features/errors_spec.rb

@@ -1,47 +0,0 @@
-require 'rails_helper'
-describe "Errors feature" do
-  before do
-    auth_as_user
-  end
-
-  it "returns 404 status code and generic error page for nonexistent records" do
-    visit "/admin/users/712323/edit"
-
-    expect(page.status_code).to eq(404)
-    within "main" do
-      expect(page).to have_text("Page not found")
-      expect(page).to have_text("You may have mistyped the address or the page may have moved")
-    end
-  end
-
-  it "returns 404 status code and generic error page for nonexistent routes" do
-    visit(releaf_root_path + "/asdassd")
-
-    expect(page.status_code).to eq(404)
-    within "main" do
-      expect(page).to have_text("Page not found")
-      expect(page).to have_text("You may have mistyped the address or the page may have moved")
-    end
-  end
-
-  it "returns 403 status code and generic error page for disabled feature" do
-    allow_any_instance_of(Releaf::Permissions::RolesController).to receive(:verify_feature_availability!)
-      .and_raise(Releaf::FeatureDisabled, "edit")
-    visit releaf_permissions_roles_path
-
-    expect(page.status_code).to eq(403)
-    within "main" do
-      expect(page).to have_text("edit feature disabled for roles")
-    end
-  end
-
-  it "returns 403 status code and generic error page for restricted content" do
-    allow_any_instance_of(Releaf::Permissions::AccessControl).to receive(:controller_permitted?).and_return(false)
-    visit releaf_permissions_roles_path
-
-    expect(page.status_code).to eq(403)
-    within "main" do
-      expect(page).to have_text("You are not authorized to access roles")
-    end
-  end
-end

data/spec/features/index_actions_spec.rb

@@ -1,86 +0,0 @@
-require 'rails_helper'
-feature "Base controller index", js: true do
-  background do
-    auth_as_user
-    author = create(:author)
-    good_book = create(:book, title: "good book", author: author, published_at: Date.parse("2015-12-12"))
-    create(:chapter, title: 'Scary night', text: 'Once upon a time...', book: good_book)
-    create(:book, title: "bad book", author: author)
-  end
-
-  scenario "shows resource count" do
-    visit admin_books_path
-    expect(page).to have_number_of_resources(2)
-  end
-
-  scenario "search resources dynamically" do
-    visit admin_books_path
-    search "good"
-    expect(page).to have_number_of_resources(1)
-
-    check "Only active"
-    expect(page).to have_number_of_resources(0)
-
-    uncheck "Only active"
-    expect(page).to have_number_of_resources(1)
-
-    fill_in "Published between", with: "2015-11-11"
-    click_button "Filter"
-
-    expect(page).to have_number_of_resources(1)
-  end
-
-  scenario "search by 2nd level nested fields" do
-    visit admin_authors_path
-    search "upon"
-    expect(page).to have_number_of_resources(1)
-  end
-
-  scenario "search nonexisting stuff" do
-    visit admin_authors_path
-    search "bunnyrabit"
-    expect(page).to have_number_of_resources(0)
-  end
-
-  scenario "no row urls when :edit feature is not available" do
-    visit admin_books_path
-    expect(page).to have_link("good book")
-
-    allow_any_instance_of(Admin::BooksController).to receive(:feature_available?).and_call_original
-    allow_any_instance_of(Admin::BooksController).to receive(:feature_available?).with(:edit).and_return(false)
-    visit admin_books_path
-    expect(page).to_not have_link("good book")
-  end
-
-  scenario "keeps search parameters when navigating to edit and back" do
-    visit admin_books_path(search: "good")
-    click_link("good book")
-    wait_for_all_richtexts
-    click_link("Back to list")
-    expect(page).to have_number_of_resources(1)
-  end
-
-  scenario "keeps search parameters after delete" do
-    visit admin_books_path(search: "good")
-    open_toolbox_dialog('Delete', Book.first)
-    click_button("Yes")
-    expect(page).to have_number_of_resources(0)
-  end
-
-  scenario "when deleting item in edit" do
-    visit admin_books_path(search: "good")
-    click_link("good book")
-    open_toolbox_dialog('Delete')
-    click_button("Yes")
-    expect(page).to have_number_of_resources(0)
-  end
-
-  scenario "when deleting item with restrict relation" do
-    visit admin_authors_path
-    open_toolbox_dialog('Delete', Author.first)
-
-    within_dialog do
-      expect(page).to have_css('.restricted-relations .relations li', count: 2)
-    end
-  end
-end

data/spec/features/index_table_spec.rb

@@ -1,35 +0,0 @@
-require 'rails_helper'
-feature "Index tables" do
-  background do
-    auth_as_user
-    publisher = create(:publisher, title: "ABC books")
-    author = create(:author, publisher: publisher)
-    another_author = create(:author, name: "Steve", publisher: nil)
-    @book_1 = create(:book, title: "good book", author: author)
-    @book_2 = create(:book, title: "steevs book", author: another_author)
-  end
-
-  scenario "shows books author publisher title" do
-    visit admin_books_path
-
-    within ".table.books thead tr" do
-      cells = [
-        "Title", "Year", "Author", "Genre", "Active", "Published at",
-        "Price", "Stars", "Description", "Author publisher title"
-      ]
-      expect(page).to have_cells_text(cells, type: "th")
-    end
-
-    within ".table.books tbody" do
-      within "tr[data-id='#{@book_1.id}']" do
-        cells = ["good book", "", "Aleksandrs Lielais", "", "", "No", "", "", "", "ABC books"]
-        expect(page).to have_cells_text(cells)
-      end
-
-      within "tr[data-id='#{@book_2.id}']" do
-        cells = ["steevs book", "", "Steve Lielais", "", "", "No", "", "", "", ""]
-        expect(page).to have_cells_text(cells)
-      end
-    end
-  end
-end

data/spec/features/menu_spec.rb

@@ -1,71 +0,0 @@
-require 'rails_helper'
-describe "Side menu visual appearance", js: true  do
-  before do
-    Rails.cache.clear
-    @user = auth_as_user
-    visit releaf_permissions_user_profile_path
-  end
-
-  describe "collapsing functionality" do
-    context "when logged first time" do
-      it "has side menu opened" do
-        expect(page).to_not have_css('body.side-compact')
-      end
-    end
-
-    context "when click to collapse button" do
-      it "collapses side menu" do
-        find('aside .compacter button').click
-
-        expect(page).to have_css('body.side-compact')
-      end
-
-      it "has permanent collapsing status" do
-        find('aside .compacter button').click
-        wait_for_settings_update('releaf.side.compact')
-        visit releaf_permissions_user_profile_path
-
-        expect(page).to have_css('body.side-compact')
-      end
-    end
-  end
-
-  describe "menu groups collapsing" do
-    context "when logged first time" do
-      it "menu item groups is not collapsed" do
-        expect(page).to have_css('aside li[data-name="permissions"]:not(.collapsed)')
-      end
-    end
-
-    context "when collapsing submenu group with active item" do
-      it "collapses menu group" do
-        find('aside li[data-name="permissions"] > .trigger').click
-        expect(page).to have_css('aside li[data-name="permissions"].collapsed')
-      end
-
-      it "does not keep menu group collapsing permanent" do
-        find('aside li[data-name="permissions"] > .trigger').click
-        wait_for_settings_update('releaf.menu.collapsed.permissions')
-
-        visit releaf_permissions_users_path
-        expect(page).to have_css('aside li[data-name="permissions"]:not(.collapsed)')
-      end
-    end
-
-    context "when collapsing submenu group without active item" do
-      it "collapses menu group" do
-        find('aside li[data-name="inventory"] > .trigger').click
-
-        expect(page).to have_css('aside li[data-name="inventory"].collapsed')
-      end
-
-      it "keeps menu group collapsing permanent" do
-        find('aside li[data-name="inventory"] > .trigger').click
-        wait_for_settings_update('releaf.menu.collapsed.inventory')
-        visit releaf_permissions_user_profile_path
-
-        expect(page).to have_css('aside li[data-name="inventory"].collapsed')
-      end
-    end
-  end
-end

data/spec/features/richtext_attachments_spec.rb

@@ -1,64 +0,0 @@
-require 'rails_helper'
-feature "Richtext attachments", js: true do
-  background do
-    # preload ActsAsNode classes
-    Rails.application.eager_load!
-    auth_as_user
-  end
-
-  scenario "Upload image and insert it within text" do
-    visit new_admin_node_path(content_type: 'HomePage')
-    fill_in("Name", with: "Image test")
-    select('en', from: 'Locale')
-
-    status_script = 'CKEDITOR.instances["resource_content_attributes_intro_text_html"].status=="ready"'
-    expect { page.evaluate_script(status_script) }.to become_true
-
-    find(".cke_toolbox a[title='Image']").click
-    expect(page).to have_css(".cke_dialog_title", text: "Image Properties")
-    click_link "Upload"
-
-    within_frame(find("iframe.cke_dialog_ui_input_file")) do
-      fixture_path = File.expand_path('../fixtures/cs.png', __dir__)
-      attach_file(:upload, fixture_path)
-    end
-
-    click_link "Send it to the Server"
-    expect(page).to have_content("Preview")
-    click_link "OK"
-
-    expect(page).to have_css(".cke_editor_resource_content_attributes_intro_text_html") # wait focus switch finished
-    save_and_check_response "Create succeeded"
-
-    visit "/image-test"
-    expect(page).to have_css("img[src='#{Releaf::RichtextAttachment.last.file.url}']")
-  end
-
-  scenario "Upload file and insert url to it" do
-    visit new_admin_node_path(content_type: 'HomePage')
-    fill_in("Name", with: "Link test")
-    select('en', from: 'Locale')
-
-    status_script = 'CKEDITOR.instances["resource_content_attributes_intro_text_html"].status=="ready"'
-    expect { page.evaluate_script(status_script) }.to become_true
-
-    find(".cke_toolbox a.cke_button__link").click
-    expect(page).to have_css(".cke_dialog_title", text: "Link")
-    click_link "Upload"
-
-    within_frame(find("iframe.cke_dialog_ui_input_file")) do
-      fixture_path = File.expand_path('../fixtures/cs.png', __dir__)
-      attach_file(:upload, fixture_path)
-    end
-
-    click_link "Send it to the Server"
-    expect(page).to have_content("Link Type")
-    click_link "OK"
-
-    expect(page).to have_css(".cke_editor_resource_content_attributes_intro_text_html") # wait focus switch finished
-    save_and_check_response "Create succeeded"
-
-    visit "/link-test"
-    expect(page).to have_css("a[href='#{Releaf::RichtextAttachment.last.file.url}']")
-  end
-end

data/spec/features/richtext_custom_config_spec.rb

@@ -1,28 +0,0 @@
-require 'rails_helper'
-feature "Richtext custom config", js: true do
-  background do
-    # preload ActsAsNode classes
-    Rails.application.eager_load!
-    auth_as_user
-  end
-
-  scenario "Add embed to richtext" do
-    visit new_admin_book_path
-    wait_for_all_richtexts
-
-    within "section[data-name=\"chapters\"]" do
-      click_button "Add item"
-      expect(page).to have_css(".cke_toolbar a.cke_button__bold")
-      expect(page).to have_css(".cke_toolbar a.cke_button__italic")
-      expect(page).to_not have_css(".cke_toolbar a.cke_button__image")
-      expect(page).to_not have_css(".cke_toolbar a.cke_button__format")
-    end
-
-    within ".field[data-name=\"summary_html\"]" do
-      expect(page).to have_css(".cke_toolbar a.cke_button__bold")
-      expect(page).to have_css(".cke_toolbar a.cke_button__italic")
-      expect(page).to have_css(".cke_toolbar a.cke_button__image")
-      expect(page).to_not have_css(".cke_toolbar a.cke_button__format")
-    end
-  end
-end

data/spec/features/richtext_embed_spec.rb

@@ -1,29 +0,0 @@
-require 'rails_helper'
-feature "Richtext embed", js: true do
-  background do
-    # preload ActsAsNode classes
-    Rails.application.eager_load!
-    auth_as_user
-  end
-
-  scenario "Add embed to richtext" do
-    visit new_admin_node_path(content_type: 'HomePage')
-    fill_in("Name", with: "Embed test")
-    select('en', from: 'Locale')
-
-    status_script = 'CKEDITOR.instances["resource_content_attributes_intro_text_html"].status=="ready"'
-    expect { page.evaluate_script(status_script) }.to become_true
-
-    find(".cke_toolbox a[title='Embed Media']").click
-    expect(page).to have_css(".cke_dialog_title", text: "Embed Media")
-
-    fill_in "Paste Embed Code Here", with: '<iframe src="500.html" />'
-    click_link "OK"
-
-    expect(page).to have_css(".cke_editor_resource_content_attributes_intro_text_html") # wait focus switch finished
-    save_and_check_response "Create succeeded"
-
-    visit "/embed-test"
-    expect(page).to have_css("iframe[src='500.html']")
-  end
-end

data/spec/features/richtext_spec.rb

@@ -1,31 +0,0 @@
-require 'rails_helper'
-feature "Richtext editing", js: true do
-  background do
-    auth_as_user
-  end
-
-  scenario "Image toolbar available when controller support attachments" do
-    visit new_admin_node_path(content_type: 'TextPage')
-    wait_for_all_richtexts
-    fill_in_richtext 'Text', with: "some text"
-    expect(page).to have_css("a.cke_button__image")
-  end
-
-  scenario "Image toolbar unavailable when controller doesn't support attachments" do
-    allow_any_instance_of(Admin::BooksController).to receive(:releaf_richtext_attachment_upload_url).and_return("")
-    visit new_admin_book_path
-    wait_for_all_richtexts
-    fill_in_richtext "Summary", with: "some text"
-    expect(page).to_not have_css("a.cke_button__image")
-  end
-
-  scenario "Test helper fills in correct value" do
-    visit new_admin_node_path(content_type: 'TextPage')
-    html = %Q[ <p class="xxx" id="yyy">&quot;HTML&quot; &#39;content&#39;</p> ]
-    wait_for_all_richtexts
-    fill_in_richtext 'Text', with: html
-    content = evaluate_script('CKEDITOR.instances["resource_content_attributes_text_html"].getData();')
-    expect(content).to match_html html
-  end
-
-end

data/spec/features/search_spec.rb

@@ -1,825 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Search do
-
-  describe "searching in models attributes" do
-    with_model :Tester, scope: :all do
-      table do |t|
-        t.string :name
-        t.string :surname
-      end
-    end
-
-    before(:all) do
-      @tester1 = Tester.create!(name: 'Jānis')
-      @tester2 = Tester.create!(name: 'Pēteris', surname: 'Grābeklis')
-      @tester3 = Tester.create!(name: 'Pēteris', surname: 'Lazdiņš')
-      @tester4 = Tester.create!(surname: 'Lazdiņš')
-    end
-
-    it "can search in single column" do
-      params = {
-        relation: Tester,
-        fields: [:name],
-        text: 'Pēteris'
-      }
-      expect( described_class.prepare(params) ).to match_array [@tester2, @tester3]
-    end
-
-    it "can search in multiple columns" do
-      params = {
-        relation: Tester,
-        fields: [:name, :surname],
-        text: 'Lazdiņš Pēteris'
-      }
-      expect( described_class.prepare(params) ).to match_array [@tester3]
-    end
-
-    it "is case insensitive" do
-      params = {
-        relation: Tester,
-        fields: [:name],
-        text: 'jānis'
-      }
-      expect( described_class.prepare(params) ).to match_array [@tester1]
-    end
-
-    it "doesn't suffer from injections" do
-      expected_results = if mysql?
-                           /LIKE '%SQL\\\'injection%'/
-                         elsif postgresql?
-                           /ILIKE '%SQL''injection%'/
-                         else
-                           fail
-                         end
-      params = {
-        relation: Tester,
-        fields: [:name],
-        text: "SQL'injection"
-      }
-      expect( described_class.prepare(params).to_sql ).to match(expected_results)
-    end
-  end
-
-  describe "searching in has_many association attributes" do
-    with_model :Programmer, scope: :all do
-      model do
-        has_many :projects
-      end
-    end
-
-    with_model :Project, scope: :all do
-      table do |t|
-        t.string :title
-        t.string :description
-        t.integer :programmer_id
-      end
-
-      model do
-        belongs_to :programmer
-      end
-    end
-
-    before(:all) do
-      @programmer1 = Programmer.create!
-      @programmer2 = Programmer.create!
-      @programmer3 = Programmer.create!
-
-      Project.create(programmer: @programmer1, title: 'Good')
-      Project.create(programmer: @programmer1, title: 'Bad', description: 'legacy code')
-      Project.create(programmer: @programmer2, title: 'Ugy', description: 'php')
-      Project.create(programmer: @programmer3, title: 'Very good')
-      Project.create(programmer: @programmer3, title: 'good', description: 'ruby')
-    end
-
-    it "finds records" do
-      params = {
-        relation: Programmer,
-        fields: [projects: [:title]],
-        text: 'bad'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer1]
-    end
-
-    it "returns distinct records" do
-      params = {
-        relation: Programmer,
-        fields: [projects: [:title]],
-        text: 'good'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer1, @programmer3]
-    end
-
-    it "searches different columns" do
-      params = {
-        relation: Programmer,
-        fields: [projects: [:title, :description]],
-        text: 'good ruby'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer3]
-    end
-  end
-
-  describe "searching in belongs_to association attributes" do
-    with_model :Programmer, scope: :all do
-      table do |t|
-        t.integer :project_manager_id
-      end
-
-      model do
-        belongs_to :project_manager
-      end
-    end
-
-    with_model :ProjectManager, scope: :all do
-      table do |t|
-        t.string :name
-        t.string :surname
-      end
-    end
-
-    before(:all) do
-      project_manager1 = ProjectManager.create!(name: 'Jānis')
-      project_manager2 = ProjectManager.create!(name: 'Pēteris', surname: 'Ozols')
-      project_manager3 = ProjectManager.create!(name: 'Jānis', surname: 'Ozols')
-
-      @programmer1 = Programmer.create!(project_manager: project_manager1)
-      @programmer2 = Programmer.create!(project_manager: project_manager2)
-      @programmer3 = Programmer.create!(project_manager: project_manager3)
-    end
-
-    it "finds records" do
-      params = {
-        relation: Programmer,
-        fields: [project_manager: [:name]],
-        text: 'pēteris'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer2]
-    end
-
-    it "searches different columns" do
-      params = {
-        relation: Programmer,
-        fields: [project_manager: [:name, :surname]],
-        text: 'jānis ozols'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer3]
-    end
-  end
-
-  describe "searching in has_one association attributes" do
-    with_model :Programmer, scope: :all do
-      model do
-        has_one :account
-      end
-    end
-
-    with_model :Account, scope: :all do
-      table do |t|
-        t.string :login
-        t.string :email
-        t.integer :programmer_id
-      end
-
-      model do
-        belongs_to :programmer
-      end
-    end
-
-    before(:all) do
-      @programmer1 = Programmer.create!
-      @programmer2 = Programmer.create!
-      @programmer3 = Programmer.create!
-
-      Account.create!(programmer: @programmer1, login: 'god', email: 'god@example.com')
-      Account.create!(programmer: @programmer2, login: 'devil', email: 'devil@example.com')
-      Account.create!(programmer: @programmer3, login: 'unknown', email: 'who@example.com')
-    end
-
-    it "finds records" do
-      params = {
-        relation: Programmer,
-        fields: [account: [:login]],
-        text: 'god'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer1]
-    end
-
-    it "searches different columns" do
-      params = {
-        relation: Programmer,
-        fields: [account: [:login, :email]],
-        text: 'unknown who'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer3]
-    end
-
-  end
-
-  describe "searching in has_many through assocation attributes" do
-    with_model :Programmer, scope: :all do
-      model do
-        has_many :commits
-        has_many :projects, through: :commits
-      end
-    end
-
-    with_model :Commit, scope: :all do
-      table do |t|
-        t.integer :programmer_id
-        t.integer :project_id
-      end
-
-      model do
-        belongs_to :programmer
-        belongs_to :project
-      end
-    end
-
-    with_model :Project, scope: :all do
-      table do |t|
-        t.string :name
-        t.string :description
-      end
-    end
-
-    before(:all) do
-      @programmer1 = Programmer.create!
-      @programmer2 = Programmer.create!
-      @programmer3 = Programmer.create!
-
-      project1 = Project.create!(name: 'Good')
-      project2 = Project.create!(name: 'Bad', description: 'legacy code')
-      project3 = Project.create!(name: 'Ugy', description: 'php')
-      project4 = Project.create!(name: 'Very good')
-      project5 = Project.create!(name: 'good', description: 'ruby')
-
-      Commit.create!(programmer: @programmer1, project: project1)
-      Commit.create!(programmer: @programmer1, project: project2)
-      Commit.create!(programmer: @programmer2, project: project2)
-      Commit.create!(programmer: @programmer2, project: project3)
-      Commit.create!(programmer: @programmer1, project: project4)
-      Commit.create!(programmer: @programmer3, project: project5)
-    end
-
-    it "finds records" do
-      params = {
-        relation: Programmer,
-        fields: [projects: [:name, :description]],
-        text: 'good'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer1, @programmer3]
-    end
-  end
-
-  describe "searching in has_one through assocation attributes" do
-    with_model :Supplier, scope: :all do
-      model do |t|
-        has_one :account
-        has_one :account_history, through: :account
-      end
-    end
-
-    with_model :Account, scope: :all do
-      table do |t|
-        t.integer :supplier_id
-      end
-
-      model do
-        belongs_to :supplier
-        has_one :account_history
-      end
-    end
-
-    with_model :AccountHistory, scope: :all do
-      table do |t|
-        t.integer :account_id
-        t.string :old_login
-      end
-
-      model do
-        belongs_to :account
-      end
-    end
-
-    before(:all) do
-      @supplier1 = Supplier.create!
-      @supplier2 = Supplier.create!
-      @supplier3 = Supplier.create!
-
-      account1 = Account.create!(supplier: @supplier1)
-      account2 = Account.create!(supplier: @supplier2)
-      account3 = Account.create!(supplier: @supplier3)
-
-      AccountHistory.create!(account: account1, old_login: 'marusja')
-      AccountHistory.create!(account: account2, old_login: 'ķirmis')
-      AccountHistory.create!(account: account3, old_login: 'grauzējs')
-    end
-
-    it "finds correct records" do
-      params = {
-        relation: Supplier,
-        fields: [account_history: [:old_login]],
-        text: 'ķirmis'
-      }
-      expect( described_class.prepare(params) ).to match_array [@supplier2]
-    end
-
-  end
-
-  describe "searching in polymorphic has_many association" do
-    with_model :Note, scope: :all do
-      table do |t|
-        t.integer :owner_id
-        t.string :owner_type
-        t.string :text
-      end
-
-      model do
-        belongs_to :owner, polymorphic: true
-      end
-    end
-
-    with_model :Account, scope: :all do
-      model do
-        has_many :notes, as: :owner
-      end
-    end
-
-    with_model :Supplier, scope: :all do
-      model do
-        has_many :notes, as: :owner
-      end
-    end
-
-    before(:all) do
-      @account1 = Account.create!
-      @account2 = Account.create!
-      @supplier1 = Supplier.create!
-      @supplier2 = Supplier.create!
-
-      Note.create!(owner: @account1, text: 'one')
-      Note.create!(owner: @supplier1, text: 'two')
-      Note.create!(owner: @account2, text: 'three')
-      Note.create!(owner: @supplier2, text: 'four')
-    end
-
-    it "finds correct record" do
-      params = {
-        relation: Account,
-        fields: [notes: [:text]],
-        text: 'one'
-      }
-      expect( described_class.prepare(params) ).to match_array [@account1]
-    end
-
-    it "uses owner_type when joining" do
-      params = {
-        relation: Account,
-        fields: [notes: [:text]],
-        text: 'two'
-      }
-      expect( described_class.prepare(params) ).to match_array []
-    end
-  end
-
-  describe "searching in polymorphic has_one association" do
-    with_model :Note, scope: :all do
-      table do |t|
-        t.integer :owner_id
-        t.string :owner_type
-        t.string :text
-      end
-
-      model do
-        belongs_to :owner, polymorphic: true
-      end
-    end
-
-    with_model :Account, scope: :all do
-      model do
-        has_one :note, as: :owner
-      end
-    end
-
-    with_model :Supplier, scope: :all do
-      model do
-        has_one :note, as: :owner
-      end
-    end
-
-    before(:all) do
-      @account1 = Account.create!
-      @account2 = Account.create!
-      @supplier1 = Supplier.create!
-      @supplier2 = Supplier.create!
-
-      Note.create!(owner: @account1, text: 'one')
-      Note.create!(owner: @supplier1, text: 'two')
-      Note.create!(owner: @account2, text: 'three')
-      Note.create!(owner: @supplier2, text: 'four')
-    end
-
-    it "finds correct record" do
-      params = {
-        relation: Account,
-        fields: [note: [:text]],
-        text: 'one'
-      }
-      expect( described_class.prepare(params) ).to match_array [@account1]
-    end
-
-    it "uses owner_type when joining" do
-      params = {
-        relation: Account,
-        fields: [note: [:text]],
-        text: 'two'
-      }
-      expect( described_class.prepare(params) ).to match_array []
-    end
-
-  end
-
-  describe "searching in scoped association" do
-    with_model :Post, scope: :all do
-      model do
-        has_many :comments, -> { where(deleted: false) }
-        has_many :deleted_comments, -> { where(deleted: true) }, class_name: :Comment
-      end
-    end
-
-    with_model :Comment, scope: :all do
-      table do |t|
-        t.integer :post_id
-        t.boolean :deleted, default: false
-        t.string :text
-      end
-
-      model do
-        belongs_to :post, required: false
-      end
-    end
-
-    before(:all) do
-      @post1 = Post.create!
-      @post2 = Post.create!
-      @post3 = Post.create!
-
-      Comment.create!(post: @post1, text: 'one')
-      Comment.create!(post: @post2, text: 'one', deleted: true)
-      Comment.create!(post: @post3, text: 'two')
-      Comment.create!(post: @post3, text: 'one', deleted: true)
-    end
-
-    it "finds correct records" do
-      params = {
-        relation: Post,
-        fields: [comments: [:text]],
-        text: 'one'
-      }
-      expect( described_class.prepare(params) ).to match_array [@post1]
-    end
-
-    it "finds correct records" do
-      params = {
-        relation: Post,
-        fields: [deleted_comments: [:text]],
-        text: 'one'
-      }
-      expect( described_class.prepare(params) ).to match_array [@post2, @post3]
-    end
-  end
-
-  describe "searching in same table through different associations" do
-
-    with_model :Writer, scope: :all do
-      table do |t|
-        t.string :name
-      end
-    end
-
-    with_model :Post, scope: :all do
-      table do |t|
-        t.integer :writer_id
-        t.integer :editor_id
-      end
-
-      model do
-        belongs_to :writer, class_name: :Writer, required: false
-        belongs_to :editor, class_name: :Writer, required: false
-      end
-    end
-
-    before(:all) do
-      writer1 = Writer.create!(name: 'Jānis')
-      writer2 = Writer.create!(name: 'Pēteris')
-      writer3 = Writer.create!(name: 'Juris')
-      writer4 = Writer.create!(name: 'Jurģis')
-
-      @post1 = Post.create!(writer: writer1, editor: writer2)
-      @post2 = Post.create!(writer: writer1, editor: writer3)
-      @post3 = Post.create!(writer: writer2, editor: writer1)
-      @post4 = Post.create!(writer: writer2)
-      @post5 = Post.create!(writer: writer3, editor: writer4)
-      @post6 = Post.create!(                 editor: writer3)
-    end
-
-    it "returns correct records" do
-      params = {
-        relation: Post,
-        fields: [writer: [:name], editor: [:name]],
-        text: 'Pēteris'
-      }
-      expect( described_class.prepare(params) ).to match_array [@post1, @post3, @post4]
-    end
-
-    it "returns correct records" do
-      params = {
-        relation: Post,
-        fields: [writer: [:name], editor: [:name]],
-        text: 'Juris'
-      }
-      expect( described_class.prepare(params) ).to match_array [@post2, @post5, @post6]
-    end
-  end
-
-  describe "searching in association table that is already joined" do
-    with_model :Writer, scope: :all do
-      table do |t|
-        t.string :name
-      end
-    end
-
-    with_model :Post, scope: :all do
-      table do |t|
-        t.integer :writer_id
-      end
-
-      model do
-        belongs_to :writer, required: false
-      end
-    end
-
-    before(:all) do
-      writer1 = Writer.create!(name: 'Jānis')
-      writer2 = Writer.create!(name: 'Pēteris')
-      writer3 = Writer.create!(name: 'Juris')
-      writer4 = Writer.create!(name: 'Jurģis')
-
-      @post1 = Post.create!(writer: writer1)
-      @post2 = Post.create!(writer: writer1)
-      @post3 = Post.create!(writer: writer2)
-      @post4 = Post.create!(writer: writer2)
-      @post5 = Post.create!(writer: writer3)
-      @post6 = Post.create!
-    end
-
-    it "returns correct records" do
-      params = {
-        relation: Post.joins(:writer),
-        fields: [writer: [:name]],
-        text: 'Pēteris'
-      }
-      expect( described_class.prepare(params) ).to match_array [@post3, @post4]
-    end
-  end
-
-  describe "searching deeply nested attributes" do
-    with_model :Programmer, scope: :all do
-      table do |t|
-        t.integer :manager_id
-      end
-
-      model do
-        belongs_to :manager, class_name: :ProjectManager
-      end
-    end
-
-    with_model :ProjectManager, scope: :all do
-      table do |t|
-        t.string :name
-        t.string :surname
-      end
-
-      model do
-        has_many :programmers, foreign_key: :manager_id
-        has_many :projects, foreign_key: :manager_id
-      end
-    end
-
-    with_model :Project, scope: :all do
-      table do |t|
-        t.string :name
-        t.integer :manager_id
-      end
-
-      model do
-        belongs_to :manager, class_name: :ProjectManager
-      end
-    end
-
-    before(:all) do
-      manager1 = ProjectManager.create!
-      manager2 = ProjectManager.create!
-      manager3 = ProjectManager.create!
-
-      @programmer1 = Programmer.create!(manager: manager1)
-      @programmer2 = Programmer.create!(manager: manager2)
-      @programmer3 = Programmer.create!(manager: manager2)
-
-      Project.create!(name: 'one', manager: manager1)
-      Project.create!(name: 'two', manager: manager1)
-      Project.create!(name: 'three', manager: manager2)
-      Project.create!(name: 'four', manager: manager3)
-    end
-
-    it "returns correct records" do
-      params = {
-        relation: Programmer,
-        fields: [manager: [projects: [:name]]],
-        text: 'three'
-      }
-      expect( described_class.prepare(params) ).to match_array [@programmer2, @programmer3]
-    end
-  end
-
-  describe "searching with joins and includes" do
-    with_model :Writer, scope: :all do
-      table do |t|
-        t.string :name
-      end
-    end
-
-    with_model :Post, scope: :all do
-      table do |t|
-        t.integer :writer_id
-      end
-
-      model do
-        belongs_to :writer, required: false
-      end
-    end
-
-    before(:all) do
-      writer1 = Writer.create!(name: 'Jānis')
-      writer2 = Writer.create!(name: 'Pēteris')
-      writer3 = Writer.create!(name: 'Juris')
-      writer4 = Writer.create!(name: 'Jurģis')
-
-      @post1 = Post.create!(writer: writer1)
-      @post2 = Post.create!(writer: writer1)
-      @post3 = Post.create!(writer: writer2)
-      @post4 = Post.create!(writer: writer2)
-      @post5 = Post.create!(writer: writer3)
-      @post6 = Post.create!
-    end
-
-    it "returns correct records" do
-      params = {
-        relation: Post.includes(:writer).references(:writer),
-        fields: [writer: [:name]],
-        text: 'Pēteris'
-      }
-      expect( described_class.prepare(params) ).to match_array [@post3, @post4]
-    end
-  end
-
-  describe "searching in polymorphic association form STI class" do
-    with_model :Note, scope: :all do
-      table do |t|
-        t.integer :owner_id
-        t.string :owner_type
-        t.string :text
-      end
-
-      model do
-        belongs_to :owner, polymorphic: true
-      end
-    end
-
-    with_model :Account, scope: :all do
-      table do |t|
-        t.string :type
-      end
-
-      model do
-        has_many :notes, as: :owner
-      end
-    end
-
-    before(:all) do
-      class SecretAccount < Account; end
-
-      @account1 = Account.create!
-      @account2 = SecretAccount.create!
-      @account3 = Account.create!
-      @account4 = SecretAccount.create!
-
-      Note.create!(owner: @account1, text: 'one')
-      Note.create!(owner: @account2, text: 'two')
-      Note.create!(owner: @account3, text: 'three')
-      Note.create!(owner: @account4, text: 'four')
-    end
-
-    after(:all) do
-      # clenaup temp constant
-      Object.send(:remove_const, :SecretAccount) if Object.constants.include?(:SecretAccount)
-    end
-
-    it "finds correct record" do
-      params = {
-        relation: SecretAccount,
-        fields: [notes: [:text]],
-        text: 'one'
-      }
-      expect( described_class.prepare(params) ).to match_array []
-    end
-
-    it "finds correct record" do
-      params = {
-        relation: SecretAccount,
-        fields: [notes: [:text]],
-        text: 'two'
-      }
-      expect( described_class.prepare(params) ).to match_array [@account2]
-    end
-
-    it "finds correct record" do
-      params = {
-        relation: Account,
-        fields: [notes: [:text]],
-        text: 'two'
-      }
-      expect( described_class.prepare(params) ).to match_array [@account2]
-    end
-
-    it "finds correct record" do
-      params = {
-        relation: Account,
-        fields: [notes: [:text]],
-        text: 'one'
-      }
-      expect( described_class.prepare(params) ).to match_array [@account1]
-    end
-
-  end
-
-  describe "searching in localized attributes" do
-
-    with_model :Post, scope: :all do
-      model do
-        translates :title
-        globalize_accessors
-      end
-    end
-
-    with_model :PostTranslation, scope: :all do
-      table do |t|
-        t.integer Post.reflect_on_association(:translations).foreign_key
-        t.string :locale
-        t.string :title
-      end
-    end
-
-    before(:all) do
-      Post::Translation.send(:table_name=, PostTranslation.table_name)
-
-      @post1 = Post.create!(title_lv: 'bar', title_en: 'foo')
-      @post2 = Post.create!(title_lv: 'foo', title_en: 'bar')
-      @post3 = Post.create!(title_lv: 'foo', title_en: 'foo')
-      @post4 = Post.create!(title_lv: 'bar', title_en: 'bar')
-    end
-
-    context "when current locale is lv" do
-      before(:each) do
-        I18n.locale = 'lv'
-      end
-
-      after(:each) do
-        I18n.locale = 'en'
-      end
-
-      it "it searches in current locale only", focus: true do
-        params = {
-          relation: Post,
-          fields: [translations: [:title]],
-          text: 'foo'
-        }
-        expect( described_class.prepare(params) ).to match_array [@post2, @post3]
-      end
-    end
-
-    context "when current locale is en" do
-      it "it searches in current locale only", focus: true do
-        params = {
-          relation: Post,
-          fields: [translations: [:title]],
-          text: 'foo'
-        }
-        expect( described_class.prepare(params) ).to match_array [@post1, @post3]
-      end
-    end
-
-  end
-
-end