ditty 0.7.1 → 0.10.1

data/spec/ditty/helpers/component_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ditty/controllers/component_controller'
+require 'ditty/helpers/component'
+require 'ditty/models/user'
+
+class DummyComponentController < ::Ditty::ComponentController
+  set model_class: Ditty::User
+
+  FILTERS = [{ name: :email }].freeze
+  SEARCHABLE = %i[name email].freeze
+end
+
+describe ::Ditty::Helpers::Component do
+  def app
+    DummyComponentController
+  end
+
+  let(:user) { create(:super_admin_user) }
+  let(:model) { create(app.model_class.name.to_sym) }
+  let(:create_data) do
+    group = described_class.model_class.to_s.demodulize.underscore
+    identity = build(:identity).to_hash
+    identity['password_confirmation'] = identity['password'] = 'som3Password!'
+    {
+      group => build(described_class.model_class.name.to_sym).to_hash,
+      'identity' => identity
+    }
+  end
+  let(:update_data) do
+    group = described_class.model_class.to_s.demodulize.underscore
+    { group => build(described_class.model_class.name.to_sym).to_hash }
+  end
+  let(:invalid_create_data) do
+    group = described_class.model_class.to_s.demodulize.underscore
+    { group => { email: 'invalidemail' } }
+  end
+  let(:invalid_update_data) do
+    group = described_class.model_class.to_s.demodulize.underscore
+    { group => { email: 'invalidemail' } }
+  end
+
+  before do
+    env 'rack.session', 'user_id' => user.id
+    create(:user, email: 'bruce@wayne.com')
+    create(:user, email: 'tony@stark.com')
+  end
+
+  describe 'filters' do
+    it 'returns the matching items' do
+      header 'Accept', 'application/json'
+      get '/', email: 'bruce@wayne.com'
+
+      response = JSON.parse last_response.body
+      expect(response['count']).to eq(1)
+    end
+
+    it 'returns no items' do
+      header 'Accept', 'application/json'
+      get '/', email: 'not found'
+
+      response = JSON.parse last_response.body
+      expect(response['count']).to eq(0)
+    end
+  end
+
+  describe 'search' do
+    it 'returns the matching items' do
+      header 'Accept', 'application/json'
+      get '/', q: 'wayne'
+
+      response = JSON.parse last_response.body
+      expect(response['count']).to eq(1)
+    end
+
+    it 'returns no items' do
+      header 'Accept', 'application/json'
+      get '/', q: 'not found'
+
+      response = JSON.parse last_response.body
+      expect(response['count']).to eq(0)
+    end
+  end
+end

data/spec/ditty/models/user_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ditty/models/user'
+
+describe ::Ditty::User, type: :model do
+  let(:super_admin_role) { create(:role, name: 'super_admin') }
+  let(:admin_role) { create(:role, name: 'admin', parent_id: super_admin_role.id) }
+  let!(:user_role) { create(:role, name: 'user', parent_id: admin_role.id) }
+  let(:super_admin) { create(:user) }
+  let(:user) { create(:user) }
+
+  before { super_admin.add_role(super_admin_role) }
+
+  describe '#role?(check)' do
+    context 'when a user has a role without a parent' do
+      it 'returns true only for specific role' do
+        expect(user).to be_role('user')
+      end
+
+      it 'returns false for other roles' do
+        %w[admin super_admin].each do |role|
+          expect(user).not_to be_role(role)
+        end
+      end
+    end
+
+    context 'when a user has a role with descendants' do
+      it 'returns true for all descendants' do
+        %w[user admin super_admin].each do |role|
+          expect(super_admin).to be_role(role)
+        end
+      end
+    end
+  end
+end

data/spec/ditty/services/email_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ditty/services/email'
+
+describe ::Ditty::Services::Email do
+  after do
+    described_class.config = nil
+  end
+
+  context 'config!' do
+    it 'configures the Mail gem' do
+      expect(Mail).to receive(:defaults)
+      described_class.config!
+    end
+
+    it 'uses the default settings' do
+      expect(described_class).to receive(:default).and_call_original
+      described_class.config!
+    end
+  end
+
+  context 'deliver!' do
+    it 'autoloads a ditty email from a symbol' do
+      mail = Mail.new
+      expect(mail).to receive(:deliver!)
+      described_class.deliver(:base, 'test@mail.com', locals: { content: 'content' }, mail: mail)
+    end
+
+    it 'sends a mail object' do
+      mail = Mail.new
+      expect(mail).to receive(:deliver!)
+      described_class.deliver(mail)
+    end
+  end
+end

data/spec/ditty/services/logger_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'spec_helper'
+require 'ditty/services/logger'
+
+class TestLogger
+  WARN = 2
+  attr_accessor :level
+
+  def initialize(options = {})
+    @options = options
+  end
+end
+
+describe ::Ditty::Services::Logger, type: :service do
+  let(:subject) { described_class.clone }
+  let(:config_file) { File.read('./spec/fixtures/logger.yml') }
+
+  context 'initialize' do
+    it '.instance always refers to the same instance' do
+      expect(subject.instance).to eq subject.instance
+    end
+
+    it "creates default logger if config file does't exist" do
+      expect(subject.instance.loggers[0]).to be_instance_of Logger
+    end
+
+    it 'reads config from file and creates an array of loggers' do
+      ::Ditty::Services::Settings.values = nil
+      allow(File).to receive(:file?).and_return(false)
+      allow(File).to receive(:file?).with('./config/logger.yml').and_return(true)
+      allow(File).to receive(:read).and_return(config_file)
+
+      expect(subject.instance.loggers.size).to eq 4
+      expect(subject.instance.loggers[0]).to be_instance_of Logger
+      expect(subject.instance.loggers[1]).to be_instance_of TestLogger
+    end
+
+    it 'sets the correct logging level' do
+      ::Ditty::Services::Settings.values = nil
+      allow(File).to receive(:file?).and_return(false)
+      allow(File).to receive(:file?).with('./config/logger.yml').and_return(true)
+      allow(File).to receive(:read).and_return(config_file)
+      expect(subject.instance.loggers[0].level).to eq Logger::DEBUG
+      expect(subject.instance.loggers[2].level).to eq Logger::INFO
+      expect(subject.instance.loggers[3].level).to eq Logger::WARN
+    end
+  end
+
+  context 'send messages' do
+    it 'receives message and passes it to the loggers' do
+      ::Ditty::Services::Settings.values = nil
+      allow(File).to receive(:file?).and_return(false)
+      allow(File).to receive(:file?).with('./config/logger.yml').and_return(true)
+      allow(File).to receive(:read).and_return(config_file)
+      allow(Logger).to receive(:warn).with('Some message')
+      allow(TestLogger).to receive(:warn).with('Some message')
+
+      expect(subject.instance.loggers[0]).to receive(:warn).with('Some message')
+      expect(subject.instance.loggers[1]).to receive(:warn).with('Some message')
+      expect($stdout).to receive(:write).with(/Some message$/)
+      expect($stderr).to receive(:write).with(/Some message$/)
+
+      subject.instance.warn 'Some message'
+    end
+  end
+end

data/spec/ditty/services/settings_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ditty/services/settings'
+
+describe ::Ditty::Services::Settings do
+  def setup_files
+    settings = File.read('./spec/fixtures/settings.yml')
+    section = File.read('./spec/fixtures/section.yml')
+
+    allow(File).to receive(:file?).and_return(false)
+    allow(File).to receive(:file?).with('./config/settings.yml').and_return(true)
+    allow(File).to receive(:file?).with('./config/section.yml').and_return(true)
+
+    allow(File).to receive(:read).with('./config/settings.yml').and_return(settings)
+    allow(File).to receive(:read).with('./config/section.yml').and_return(section)
+  end
+
+  describe '#[]' do
+    before do
+      setup_files
+      described_class.values = nil
+    end
+
+    it 'returns the specified values from the global settings' do
+      expect(described_class[:option_a]).to eq 1
+    end
+
+    it 'allows access to sectional settings' do
+      expect(described_class[:no_file_section]).to include(section_1: 2, section_2: 'set')
+    end
+
+    it 'allows using dots to travers' do
+      expect(described_class['nested.option']).to eq 'value'
+    end
+  end
+
+  describe '#values' do
+    context 'uses the global file' do
+      before do
+        setup_files
+      end
+
+      it 'to return global settings' do
+        expect(described_class.values).to include(option_a: 1, option_b: 'value')
+      end
+
+      it 'to return sectional settings' do
+        expect(described_class.values(:no_file_section)).to include(section_1: 2, section_2: 'set')
+      end
+    end
+
+    context 'uses the sectional file' do
+      before do
+        setup_files
+      end
+
+      it 'prefers the sectional settings file' do
+        expect(described_class.values(:section)).to include(section_1: 3, section_2: 'section')
+      end
+    end
+  end
+end

data/spec/ditty_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ::Ditty do
+  it 'has a version number' do
+    expect(Ditty::VERSION).not_to be nil
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'faker'
+require 'ditty/models/user'
+require 'ditty/models/identity'
+require 'ditty/models/role'
+require 'ditty/models/user_login_trait'
+
+FactoryBot.define do
+  to_create(&:save)
+
+  sequence(:email) { |n| "person-#{n}@example.com" }
+  sequence(:name) { |n| "Name-#{n}" }
+
+  factory :user, class: 'Ditty::User', aliases: [:'Ditty::User'] do
+    email
+
+    after(:create) do |user, _evaluator|
+      create(:identity, user: user)
+    end
+
+    factory :super_admin_user do
+      after(:create) do |user, _evaluator|
+        user.add_role(Ditty::Role.find_or_create(name: 'super_admin'))
+      end
+    end
+  end
+
+  factory :identity, class: 'Ditty::Identity', aliases: [:'Ditty::Identity'] do
+    username { generate :email }
+    crypted_password { 'som3Password!' }
+  end
+
+  factory :role, class: 'Ditty::Role', aliases: [:'Ditty::Role'] do
+    name { "Role #{generate(:name)}" }
+    parent_id { nil }
+  end
+
+  factory :user_login_trait, class: 'Ditty::UserLoginTrait', aliases: [:'Ditty::UserLoginTrait'] do
+    association :user, strategy: :create, factory: :user
+    ip_address { Faker::Internet.ip_v4_address }
+    platform { Faker::Device.platform }
+    device { Faker::Device.model_name }
+    browser { 'Firefox' }
+  end
+end

data/spec/fixtures/logger.yml

@@ -0,0 +1,17 @@
+loggers:
+- name: file
+  class: Logger
+  level: 'DEBUG'
+- name: ES
+  class: TestLogger
+  options:
+    url: 'http://logging.ditty.io:9200'
+    log: false
+- name: stdout
+  class: Logger
+  options: '$stdout'
+  level: INFO
+- name: stderr
+  class: Logger
+  options: '$stderr'
+  level: WARN

data/spec/fixtures/section.yml

@@ -0,0 +1,3 @@
+---
+section_1: 3
+section_2: section

data/spec/fixtures/settings.yml

@@ -0,0 +1,8 @@
+---
+option_a: 1
+option_b: value
+no_file_section:
+  section_1: 2
+  section_2: set
+nested:
+  option: value

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'dotenv'
+Dotenv.load('.env.test')
+Dotenv.overload('.env.test.local')
+
+ENV['APP_ENV'] ||= 'test'
+ENV['RACK_ENV'] ||= 'test'
+require 'simplecov'
+SimpleCov.start
+
+ENV['DATABASE_URL'] ||= 'sqlite::memory:'
+
+require 'ditty'
+require 'ditty/db'
+require 'rspec'
+require 'rack/test'
+require 'factory_bot'
+require 'database_cleaner'
+require 'timecop'
+
+if ENV['DATABASE_URL'] == 'sqlite::memory:'
+  folder = File.expand_path("#{File.dirname(__FILE__)}/../migrate")
+  Sequel.extension :migration
+  Sequel::Migrator.apply(DB, folder)
+
+  # Seed the DB
+  require 'ditty/seed'
+end
+
+Ditty.component :ditty
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+  config.include FactoryBot::Syntax::Methods
+
+  config.alias_example_to :fit, focus: true
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    FactoryBot.find_definitions
+    Timecop.freeze
+  end
+
+  config.around do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end

data/spec/support/api_shared_examples.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'active_support/core_ext/hash/except'
+
+shared_examples 'an API interface' do |subject, params|
+  before { create(subject) }
+
+  context 'GET /' do
+    it 'returns HTML when requested' do
+      header 'Accept', 'text/html'
+      get '/'
+
+      expect(last_response).to be_ok
+      expect(last_response.headers['Content-Type']).to include('text/html;charset=utf-8')
+    end
+
+    it 'returns JSON when requested' do
+      header 'Accept', 'application/json'
+      get '/'
+
+      expect(last_response).to be_ok
+      expect(last_response.headers).to include('Content-Type' => 'application/json')
+      expect { JSON.parse(last_response.body) }.not_to raise_error
+    end
+
+    it 'returns a list object' do
+      header 'Accept', 'application/json'
+      get '/'
+
+      response = JSON.parse last_response.body
+      expect(response).to include('page', 'count', 'total', 'items')
+      expect(response['page']).to be_an Integer
+      expect(response['count']).to be_an Integer
+      expect(response['total']).to be_an Integer
+      expect(response['items']).to be_an Array
+    end
+  end
+
+  context 'GET /id' do
+    let(:entity) { create(subject) }
+
+    it 'returns HTML when requested' do
+      header 'Accept', 'text/html'
+      get "/#{entity.id}"
+
+      expect(last_response).to be_ok
+      expect(last_response.headers).to include('Content-Type' => 'text/html;charset=utf-8')
+    end
+
+    it 'returns JSON when requested' do
+      header 'Accept', 'application/json'
+      get "/#{entity.id}"
+
+      expect(last_response).to be_ok
+      expect(last_response.headers).to include('Content-Type' => 'application/json')
+      expect { JSON.parse(last_response.body) }.not_to raise_error
+    end
+
+    it 'returns the fetched object' do
+      header 'Accept', 'application/json'
+      get "/#{entity.id}"
+
+      response = JSON.parse last_response.body
+      expect(response).to be_a Hash
+      entity_to_json = JSON.parse entity.values.to_json
+      expect(response).to include(entity_to_json)
+    end
+  end
+
+  context 'POST /' do
+    it 'returns HTML when requested' do
+      header 'Accept', 'text/html'
+      header 'Content-Type', 'application/x-www-form-urlencoded'
+      params[subject] = build(subject).to_hash
+      post '/', params
+
+      expect(last_response.headers).to include('Content-Type' => 'text/html;charset=utf-8')
+    end
+
+    it 'returns a 302 Redirect response for a HTML Request' do
+      header 'Accept', 'text/html'
+      header 'Content-Type', 'application/x-www-form-urlencoded'
+      params[subject] = build(subject).to_hash
+      post '/', params
+
+      expect(last_response.status).to eq 302
+      expect(last_response.headers).to include('Location')
+    end
+
+    it 'returns JSON when requested' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+      params[subject] = build(subject).to_hash
+      post '/', params.to_json
+
+      expect(last_response.headers).to include('Content-Type' => 'application/json')
+    end
+
+    it 'returns a 201 Created response for a JSON Request' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+      params[subject] = build(subject).to_hash
+      post '/', params.to_json
+
+      expect(last_response.status).to eq 201
+    end
+
+    it 'returns a Location Header for a JSON Request' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+      params[subject] = build(subject).to_hash
+      post '/', params.to_json
+
+      expect(last_response.headers).to include 'Location'
+    end
+
+    it 'returns an empty body for a JSON Request' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+      params[subject] = build(subject).to_hash
+      post '/', params.to_json
+
+      expect(last_response.body).to eq ''
+    end
+  end
+
+  context 'PUT /:id' do
+    let(:entity) { create(subject) }
+
+    it 'returns HTML when requested' do
+      header 'Accept', 'text/html'
+      header 'Content-Type', 'application/x-www-form-urlencoded'
+
+      values = entity.to_hash.except(:id)
+      params[subject] = values
+      put "/#{entity.id}", params
+
+      expect(last_response.headers).to include('Content-Type' => 'text/html;charset=utf-8')
+    end
+
+    it 'returns a 302 Redirect response for a HTML Request' do
+      header 'Accept', 'text/html'
+      header 'Content-Type', 'application/x-www-form-urlencoded'
+
+      values = entity.to_hash.except(:id)
+      params[subject] = values
+      put "/#{entity.id}", params
+
+      expect(last_response.status).to eq 302
+      expect(last_response.headers).to include('Location')
+    end
+
+    it 'returns JSON when requested' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+
+      values = entity.to_hash.except(:id)
+      params[subject] = values
+      put "/#{entity.id}", params.to_json
+
+      expect(last_response.headers).to include('Content-Type' => 'application/json')
+    end
+
+    it 'returns a 200 OK response for a JSON Request' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+
+      values = entity.to_hash.except(:id)
+      params[subject] = values
+      put "/#{entity.id}", params.to_json
+
+      expect(last_response.status).to eq 200
+    end
+
+    it 'returns a Location Header for a JSON Request' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+
+      values = entity.to_hash.except(:id)
+      params[subject] = values
+      put "/#{entity.id}", params.to_json
+
+      expect(last_response.headers).to include 'Location'
+    end
+
+    it 'returns the updated entity in the body for a JSON Request' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+
+      values = entity.to_hash.except(:id)
+      params[subject] = values
+      put "/#{entity.id}", params.to_json
+
+      response = JSON.parse last_response.body
+      entity_to_hash = JSON.parse entity.values.to_json
+      expect(response).to eq entity_to_hash
+    end
+  end
+
+  context 'DELETE /:id' do
+    let(:entity) { create(subject) }
+
+    it 'returns HTML when requested' do
+      header 'Accept', 'text/html'
+      header 'Content-Type', 'application/x-www-form-urlencoded'
+
+      delete "/#{entity.id}"
+
+      expect(last_response.headers).to include('Content-Type' => 'text/html;charset=utf-8')
+    end
+
+    it 'returns a 302 Redirect response for a HTML Request' do
+      header 'Accept', 'text/html'
+      header 'Content-Type', 'application/x-www-form-urlencoded'
+
+      delete "/#{entity.id}"
+
+      expect(last_response.status).to eq 302
+      expect(last_response.headers).to include('Location')
+    end
+
+    it 'returns JSON when requested' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+
+      delete "/#{entity.id}"
+
+      expect(last_response.headers).to include('X-Content-Type-Options' => 'nosniff')
+    end
+
+    it 'returns a 204 No Content response for a JSON Request' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+
+      delete "/#{entity.id}"
+
+      expect(last_response.status).to eq 204
+    end
+
+    it 'returns an empty body for a JSON Request' do
+      header 'Accept', 'application/json'
+      header 'Content-Type', 'application/json'
+
+      delete "/#{entity.id}"
+
+      expect(last_response.body).to eq ''
+    end
+  end
+end