api_maker 0.0.1 → 0.0.2

data/lib/api_maker/result_parser.rb

@@ -1,14 +1,14 @@
 class ApiMaker::ResultParser
-  attr_reader :ability, :args
+  attr_reader :ability, :api_maker_args
 
   def self.parse(*args)
     ApiMaker::ResultParser.new(*args).result
   end
 
-  def initialize(object, ability: nil, args: nil, controller: nil)
+  def initialize(object, ability: nil, api_maker_args: nil, controller: nil)
     @object = object
     @ability = ability || controller&.__send__(:current_ability)
-    @args = args || controller&.__send__(:api_maker_args) || {}
+    @api_maker_args = api_maker_args || controller&.__send__(:api_maker_args) || {}
   end
 
   def result
@@ -17,32 +17,46 @@ class ApiMaker::ResultParser
 
 private
 
+  def parse_active_record(object)
+    serializer = ApiMaker::Serializer.new(ability: ability, api_maker_args: api_maker_args, model: object)
+
+    {
+      api_maker_type: :model,
+      model_name: serializer.resource.collection_name,
+      serialized: parse_object(serializer.as_json)
+    }
+  end
+
+  def parse_array(object)
+    object.map { |value| parse_object(value) }
+  end
+
+  def parse_hash(object)
+    result = {}
+    object.each do |key, value|
+      result[key] = parse_object(value)
+    end
+
+    result
+  end
+
   def parse_object(object)
     if object.is_a?(Hash)
-      result = {}
-      object.each do |key, value|
-        result[key] = parse_object(value)
-      end
-
-      result
+      parse_hash(object)
     elsif object.is_a?(Array)
-      object.map { |value| parse_object(value) }
-    elsif object.class.name == "Money"
+      parse_array(object)
+    elsif object.class.name == "Money" # rubocop:disable Style/ClassEqualityComparison
       {api_maker_type: :money, amount: object.cents, currency: object.currency.iso_code}
     elsif object.is_a?(Date)
-      object.iso8601
+      {api_maker_type: :date, value: object.iso8601}
     elsif object.is_a?(Time)
-      object.utc.iso8601
+      {api_maker_type: :time, value: object.utc.iso8601}
     elsif object.is_a?(ApiMaker::CollectionSerializer) || object.is_a?(ApiMaker::Serializer)
       parse_object(object.as_json)
+    elsif object.is_a?(Class) && object < ApiMaker::BaseResource
+      {api_maker_type: :resource, name: object.short_name}
     elsif object.is_a?(ActiveRecord::Base)
-      serializer = ApiMaker::Serializer.new(ability: ability, args: args, model: object)
-
-      {
-        api_maker_type: :model,
-        model_name: serializer.resource.collection_name,
-        serialized: parse_object(serializer.as_json)
-      }
+      parse_active_record(object)
     else
       object
     end

data/lib/api_maker/serializer.rb

@@ -1,5 +1,7 @@
 class ApiMaker::Serializer
-  attr_reader :ability, :args, :model
+  attr_reader :ability, :api_maker_args, :locals, :model
+
+  delegate :id, to: :model
 
   def self.resource_for(klass)
     ApiMaker::MemoryStorage.current.resource_for_model(klass)
@@ -11,15 +13,16 @@ class ApiMaker::Serializer
     ApiMaker::MemoryStorage.current.resource_for_model(klass)
   end
 
-  def initialize(ability: nil, args: {}, model:, select: nil)
-    @args = args
-    @model = model
+  def initialize(ability: nil, api_maker_args: {}, locals: nil, model:, select: nil)
     @ability = ability
+    @api_maker_args = api_maker_args
+    @locals = locals || api_maker_args&.dig(:locals) || {}
+    @model = model
     @select = select
   end
 
   def attributes
-    ApiMaker::Configuration.profile("attributes") do
+    profile("attributes") do
       result = {}
       attributes_to_read.each do |attribute, data|
         if (if_name = data.dig(:args, :if))
@@ -35,14 +38,18 @@ class ApiMaker::Serializer
   end
 
   def attributes_to_read
-    @attributes_to_read ||= @select || resource.default_select
+    @attributes_to_read ||= profile("attributes_to_read") do
+      @select || resource.default_select
+    end
   end
 
   def attribute_value(attribute)
-    if resource_instance.respond_to?(attribute)
-      resource_instance.__send__(attribute)
-    else
-      model.__send__(attribute)
+    profile("attribute_value #{attribute}") do
+      if resource_instance.respond_to?(attribute)
+        resource_instance.__send__(attribute)
+      else
+        model.__send__(attribute)
+      end
     end
   end
 
@@ -50,37 +57,61 @@ class ApiMaker::Serializer
     result.fetch(*args, &blk)
   end
 
+  def load_ability(ability_name, value)
+    @abilities ||= {}
+    @abilities[ability_name] = value
+  end
+
   def relationships
     @relationships ||= {}
   end
 
   def resource
-    @resource ||= ApiMaker::MemoryStorage.current.resource_for_model(model.class)
+    @resource ||= profile("resource") do
+      ApiMaker::MemoryStorage.current.resource_for_model(model.class)
+    end
   end
 
   def resource_instance
-    @resource_instance ||= resource.new(ability: ability, args: args, model: model)
+    @resource_instance ||= profile("resource_instance") do
+      resource.new(ability: ability, api_maker_args: api_maker_args, locals: locals, model: model)
+    end
   end
 
   def result
-    @result ||= begin
-      result = {a: attributes}
-      result[:r] = @relationships if @relationships # Only include relationships if set
-      result
-    end
+    result = {a: attributes}
+    result[:b] = @abilities if @abilities # Only use b-key if any abilities was loaded
+    result[:r] = @relationships if @relationships # Only preload relationships if set
+    result
   end
 
-  def as_json(_options = nil)
-    result
+  def as_json(options = nil)
+    profile("as_json") do
+      if options && options[:result_parser]
+        ApiMaker::ResultParser.new(result, ability: ability, api_maker_args: api_maker_args).result
+      else
+        result
+      end
+    end
   end
 
-  def to_json(_options = nil)
-    JSON.generate(as_json)
+  def to_json(options = nil)
+    profile("to_json") do
+      JSON.generate(as_json(options))
+    end
   end
 
   def inspect
-    "<ApiMaker::Serializer id=\"#{model.id}\" model=\"#{model.class.name}\" relationships=\"#{relationships}\">"
+    profile("inspect") do
+      "<ApiMaker::Serializer id=\"#{model.id}\" model=\"#{model.class.name}\" relationships=\"#{relationships}\">"
+    end
   end
 
   alias to_s inspect
+
+private
+
+  def profile(message, &blk)
+    ApiMaker::Configuration.profile(-> { "Serializer for #{model.class.name}: #{message}" }, &blk)
+  end
 end

data/lib/api_maker/spec_helper/browser_logs.rb

@@ -0,0 +1,14 @@
+module ApiMaker::SpecHelper::BrowserLogs
+  def browser_logs
+    logs = if browser_firefox?
+      []
+    else
+      chrome_logs
+    end
+
+    @recorded_browser_logs ||= []
+    @recorded_browser_logs += logs
+
+    logs
+  end
+end

data/lib/api_maker/spec_helper/execute_collection_command.rb

@@ -0,0 +1,46 @@
+class ApiMaker::SpecHelper::ExecuteCollectionCommand < ApiMaker::ApplicationService
+  include RSpec::Mocks::ExampleMethods
+
+  attr_reader :api_maker_args, :args, :command, :model_class
+
+  def initialize(ability: nil, api_maker_args: {}, args: {}, command:, fake_controller: nil, model_class:)
+    @ability = ability
+    @api_maker_args = api_maker_args
+    @args = args
+    @command = command
+    @fake_controller = fake_controller
+    @model_class = model_class
+  end
+
+  def perform
+    helper_command
+    helper.execute!
+    succeed! helper_command.result
+  end
+
+  def ability
+    @ability ||= ApiMaker::Ability.new(api_maker_args: api_maker_args)
+  end
+
+  def fake_controller
+    @fake_controller ||= instance_double(
+      ApiMaker::BaseController,
+      api_maker_args: api_maker_args,
+      current_ability: ability
+    )
+  end
+
+  def helper
+    @helper ||= ApiMaker::CommandSpecHelper.new(
+      collection: model_class,
+      command: command,
+      controller: fake_controller
+    )
+  end
+
+  def helper_command
+    @helper_command ||= helper.add_command(
+      args: args
+    )
+  end
+end

data/lib/api_maker/spec_helper/execute_member_command.rb

@@ -0,0 +1,52 @@
+class ApiMaker::SpecHelper::ExecuteMemberCommand < ApiMaker::ApplicationService
+  include RSpec::Mocks::ExampleMethods
+
+  attr_reader :api_maker_args, :args, :command, :model
+
+  def initialize(ability: nil, api_maker_args: nil, collection: nil, command:, fake_controller: nil, model:, args: {})
+    @ability = ability
+    @api_maker_args = api_maker_args
+    @args = args
+    @collection = collection
+    @command = command
+    @fake_controller = fake_controller
+    @model = model
+  end
+
+  def perform
+    helper_command
+    helper.execute!
+    succeed! helper_command.result
+  end
+
+  def ability
+    @ability ||= ApiMaker::Ability.new(api_maker_args: api_maker_args)
+  end
+
+  def collection
+    @collection ||= model.class.where(id: model.id)
+  end
+
+  def fake_controller
+    @fake_controller ||= instance_double(
+      ApiMaker::BaseController,
+      api_maker_args: api_maker_args,
+      current_ability: ability
+    )
+  end
+
+  def helper
+    @helper ||= ApiMaker::CommandSpecHelper.new(
+      collection: collection,
+      command: command,
+      controller: fake_controller
+    )
+  end
+
+  def helper_command
+    @helper_command ||= helper.add_command(
+      primary_key: model.id,
+      args: args
+    )
+  end
+end

data/lib/api_maker/spec_helper/expect_no_browser_errors.rb

@@ -0,0 +1,18 @@
+module ApiMaker::SpecHelper::ExpectNoBrowserErrors
+  def expect_no_browser_errors
+    logs = browser_logs
+      .map(&:to_s)
+      .reject { |log| log.include?("Warning: Can't perform a React state update on an unmounted component.") }
+      .reject { |log| log.include?("DEBUG: ") }
+      .join("\n")
+
+    expect_no_browser_window_errors
+    return if logs.blank? || logs.exclude?("SEVERE ")
+
+    # Lets try one more time - just in case browser window error got registered meanwhile
+    sleep 0.4
+    expect_no_browser_window_errors
+
+    raise logs
+  end
+end

data/lib/api_maker/spec_helper/wait_for_expect.rb

@@ -0,0 +1,20 @@
+module ApiMaker::SpecHelper::WaitForExpect
+  # Waits for an expect to not fail - this is great because it whines
+  def wait_for_expect(*args)
+    last_error = nil
+
+    begin
+      wait_for_browser(*args) do
+        yield
+        true
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+        last_error = e
+        false
+      end
+    rescue WaitUtil::TimeoutError => e
+      raise last_error if last_error
+
+      raise e
+    end
+  end
+end

data/lib/api_maker/spec_helper/wait_for_flash_message.rb

@@ -0,0 +1,21 @@
+module ApiMaker::SpecHelper::WaitForFlashMessage
+  def wait_for_flash_message(expected_message, delay_sec: 0.2, timeout_sec: 6)
+    received_messages = []
+
+    WaitUtil.wait_for_condition("wait for flash message", timeout_sec: timeout_sec, delay_sec: delay_sec) do
+      expect_no_browser_errors
+      current_message = flash_message_text
+      received_messages << current_message
+
+      if current_message.is_a?(Array)
+        current_message.include?(expected_message)
+      else
+        current_message == expected_message
+      end
+    end
+
+    expect_no_browser_errors
+  rescue WaitUtil::TimeoutError
+    expect(received_messages.uniq.reject(&:blank?)).to eq include expected_message
+  end
+end

data/lib/api_maker/spec_helper.rb

@@ -1,11 +1,36 @@
-module ApiMaker::SpecHelper
+require "waitutil"
+
+module ApiMaker::SpecHelper # rubocop:disable Metrics/ModuleLength
+  autoload :ExecuteCollectionCommand, "#{__dir__}/spec_helper/execute_collection_command"
+  autoload :ExecuteMemberCommand, "#{__dir__}/spec_helper/execute_member_command"
+
+  require_relative "spec_helper/browser_logs"
+  require_relative "spec_helper/expect_no_browser_errors"
+  require_relative "spec_helper/wait_for_expect"
+  require_relative "spec_helper/wait_for_flash_message"
+  include BrowserLogs
+  include ExpectNoBrowserErrors
+  include WaitForExpect
+  include WaitForFlashMessage
+
+  class JavaScriptError < RuntimeError; end
+  class SelectorNotFoundError < RuntimeError; end
+  class SelectorFoundError < RuntimeError; end
+
+  def browser_firefox?
+    capabilities = page.driver.browser.try(:capabilities)
+    capabilities && capabilities[:browser_name] == "firefox"
+  end
+
   def chrome_logs
     page.driver.browser.manage.logs.get(:browser)
   end
 
-  def expect_no_chrome_window_errors
-    sleep 1
+  def confirm_accept
+    page.driver.browser.switch_to.alert.accept
+  end
 
+  def expect_no_browser_window_errors
     errors = execute_script("if (window.errorLogger) { return window.errorLogger.getErrors() }")
     return if !errors.is_a?(Array) || errors.empty?
 
@@ -15,81 +40,112 @@ module ApiMaker::SpecHelper
     custom_trace += last_error.fetch("backtrace") if last_error["backtrace"].is_a?(Array)
     custom_trace += caller
 
-    error = RuntimeError.new("#{last_error["errorClass"]}: #{last_error["message"]}")
+    error = JavaScriptError.new("#{last_error["errorClass"]}: #{last_error["message"]}")
     error.set_backtrace(custom_trace)
 
     raise error
   end
 
-  def expect_no_chrome_errors
-    logs = chrome_logs.map(&:to_s)
-    logs = logs.reject { |log| log.include?("Warning: Can't perform a React state update on an unmounted component.") }
-    return if !logs || !logs.join("\n").include?("SEVERE ")
+  def expect_no_errors
+    expect_no_flash_errors
+    expect_no_browser_errors
+  end
 
-    expect_no_chrome_window_errors
+  def expect_to_be_able_to(ability, model, permissions)
+    permissions.each do |permission|
+      # Test access through 'can?'
+      expect(ability).to be_able_to permission, model
 
-    puts logs.join("\n")
-    expect(logs).to eq nil
+      # Test access through 'accessible_by'
+      if model.is_a?(ActiveRecord::Base) && model.persisted?
+        readable_models = model.class.where(id: model).accessible_by(ability, permission)
+        expect(readable_models).to eq [model]
+      end
+    end
   end
 
-  def expect_no_errors
-    expect_no_flash_errors
-    expect_no_chrome_errors
+  def expect_not_to_be_able_to(ability, model, permissions)
+    permissions.each do |permission|
+      # Test access through 'can?'
+      expect(ability).not_to be_able_to permission, model
+
+      # Test access through 'accessible_by'
+      if model.is_a?(ActiveRecord::Base) && model.persisted?
+        readable_models = model.class.where(id: model).accessible_by(ability, permission)
+        expect(readable_models).to be_empty
+      end
+    end
   end
 
   def js_fill_in(element_id, with:)
     page.execute_script("document.querySelector(#{element_id.to_json}).value = #{with.to_json}")
   end
 
+  def model_row_selector(model)
+    ".#{model.model_name.singular.dasherize}-row[data-model-id='#{model.id}']"
+  end
+
   def pretty_html
     require "htmlbeautifier"
     HtmlBeautifier.beautify(page.html)
   end
 
+  def recorded_browser_logs
+    @recorded_browser_logs || []
+  end
+
   def reset_indexeddb
-    execute_script "
-      indexedDB.databases().then(function(databases) {
-        var promises = []
-        for(var database of databases) {
-          promises.push(indexedDB.deleteDatabase(database.name))
-        }
-
-        Promise.all(promises).then(function() {
-          console.error('All databases was deleted')
-        })
-      })
-    "
-
-    wait_for_condition do
-      logs_text = chrome_logs.map(&:message).join("\n")
-      logs_text.include?("\"All databases was deleted\"")
-    end
+    ApiMaker::ResetIndexedDbService.execute!(context: self)
+  end
+
+  def wait_for_action_cable_to_connect
+    sleep 0.5
+  end
+
+  def wait_for_and_find(selector, *args)
+    element = find(selector, *args)
+    expect_no_browser_errors
+    element
+  rescue Capybara::ElementNotFound => e
+    expect_no_browser_errors
+    raise ApiMaker::SpecHelper::SelectorNotFoundError, e.message
   end
 
-  def wait_for_chrome(delay_sec: 0.5, timeout_sec: 6)
-    WaitUtil.wait_for_condition("wait for chrome", timeout_sec: timeout_sec, delay_sec: delay_sec) do
-      expect_no_chrome_errors
+  def wait_for_attribute_row(attribute: nil, identifier: nil, label: nil, value: nil, **opts)
+    raise "No attribute or identifier given" if !attribute && !identifier
+    raise "No label or value was given" if !label && !value
+
+    tr_selector = ".component-api-maker-attribute-row"
+    tr_selector << "[data-attribute='#{attribute.camelize(:lower)}']" if attribute
+    tr_selector << "[data-identifier='#{identifier.camelize}']" if identifier
+
+    wait_for_selector "#{tr_selector} > .attribute-row-label", exact_text: label, **opts if label
+    wait_for_selector "#{tr_selector} > .attribute-row-value", exact_text: value, **opts if value
+  end
+
+  def wait_for_browser(delay_sec: 0.2, message: "wait for browser", timeout_sec: 6)
+    WaitUtil.wait_for_condition(message, timeout_sec: timeout_sec, delay_sec: delay_sec) do
+      expect_no_browser_errors
       yield
     end
   end
 
-  def wait_for_flash_message(expected_message, delay_sec: 0.5, timeout_sec: 10)
-    received_messages = []
+  def wait_for_path(expected_path, **args)
+    args[:ignore_query] = true unless args.key?(:ignore_query)
 
-    begin
-      WaitUtil.wait_for_condition("wait for flash message", timeout_sec: timeout_sec, delay_sec: delay_sec) do
-        expect_no_chrome_errors
-        current_message = flash_message_text
-        received_messages << current_message
-        current_message == expected_message
-      end
-    rescue WaitUtil::TimeoutError
-      expect(received_messages.uniq.reject(&:blank?)).to eq include expected_message
-    end
+    expect(page).to have_current_path(expected_path, args)
+    expect_no_browser_errors
+  rescue RSpec::Expectations::ExpectationNotMetError => e
+    expect_no_browser_errors
+    raise e
   end
 
-  def wait_for_selector(selector)
-    wait_for_chrome { page.has_selector?(selector) }
+  def wait_for_selector(selector, *args)
+    expect(page).to have_selector selector, *args
+    expect_no_browser_errors
+  rescue RSpec::Expectations::ExpectationNotMetError => e
+    expect_no_browser_errors
+    raise ApiMaker::SpecHelper::SelectorNotFoundError, e.message
   end
 
   def wait_for_selectors(*selectors)
@@ -97,4 +153,12 @@ module ApiMaker::SpecHelper
       wait_for_selector(selector)
     end
   end
+
+  def wait_for_no_selector(selector, *args)
+    expect(page).to have_no_selector selector, *args
+    expect_no_browser_errors
+  rescue RSpec::Expectations::ExpectationNotMetError => e
+    expect_no_browser_errors
+    raise ApiMaker::SpecHelper::SelectorFoundError, e.message
+  end
 end

data/lib/api_maker/version.rb

@@ -1,3 +1,3 @@
 module ApiMaker
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
 end

data/lib/api_maker.rb

@@ -1,6 +1,8 @@
 require "api_maker/engine"
 
+require "active_record_better_dependent_error_messages"
 require "active_record_query_fixer"
+require "cancancan"
 require "ransack"
 require "service_pattern"
 
@@ -11,22 +13,24 @@ module ApiMaker
 
   autoload :Ability, "#{dir}/ability"
   autoload :AbilityLoader, "#{dir}/ability_loader"
-  autoload :BaseCommand, "#{dir}/base_command"
+  autoload :BaseCollectionInstance, "#{dir}/base_collection_instance"
   autoload :BaseResource, "#{dir}/base_resource"
+  autoload :BaseService, "#{dir}/base_service"
   autoload :CollectionSerializer, "#{dir}/collection_serializer"
   autoload :CommandSpecHelper, "#{dir}/command_spec_helper"
   autoload :Configuration, "#{dir}/configuration"
+  autoload :ExpectToBeAbleToHelper, "#{dir}/expect_to_able_to_helper"
   autoload :IndividualCommand, "#{dir}/individual_command"
   autoload :Loader, "#{dir}/loader"
   autoload :MemoryStorage, "#{dir}/memory_storage"
   autoload :ModelExtensions, "#{dir}/model_extensions"
   autoload :PermittedParamsArgument, "#{dir}/permitted_params_argument"
   autoload :Preloader, "#{dir}/preloader"
+  autoload :PreloaderBase, "#{dir}/preloader_base"
   autoload :PreloaderBelongsTo, "#{dir}/preloader_belongs_to"
   autoload :PreloaderHasMany, "#{dir}/preloader_has_many"
   autoload :PreloaderHasOne, "#{dir}/preloader_has_one"
-  autoload :PreloaderThrough, "#{dir}/preloader_through"
-  autoload :RelationshipIncluder, "#{dir}/relationship_includer"
+  autoload :RelationshipPreloader, "#{dir}/relationship_preloader"
   autoload :ResourceRouting, "#{dir}/resource_routing"
   autoload :ResultParser, "#{dir}/result_parser"
   autoload :Serializer, "#{dir}/serializer"