source 'https://rubygems.org'

ruby '3.3.5'

gem 'bootsnap', require: false
gem 'importmap-rails'
gem 'jbuilder'
gem 'pg', '~> 1.1'
gem 'puma', '>= 5.0'
gem 'rails', '~> 7.1.3', '>= 7.1.3.2'
gem 'redis', '>= 4.0.1'
gem 'restforce'
gem 'sprockets-rails'
gem 'stimulus-rails'
gem 'turbo-rails'
gem 'tzinfo-data', platforms: %i[windows jruby]

group :development, :test do
  gem 'byebug', platforms: %i[mri mingw x64_mingw]
  gem 'database_cleaner'
  gem 'database_cleaner-active_record'
  gem 'debug', platforms: %i[mri windows]
  gem 'factory_bot_rails'
  gem 'faker'
  gem 'guard'
  gem 'guard-livereload'
  gem 'guard-rails', require: false
  gem 'guard-rspec'
  gem 'guard-rubocop'
  gem 'pry-byebug'
  gem 'pry-theme'
  gem 'rspec'
  gem 'rspec-rails'
  gem 'rubocop', require: false
  gem 'rubocop-performance', require: false
  gem 'rubocop-rails', require: false
  gem 'rubocop-rspec', require: false
  gem 'shoulda-matchers'
end

group :development do
  gem 'web-console'
end

group :test do
  gem 'capybara'
  gem 'selenium-webdriver'
end

# Guardfile

def rspec_guard(cmd) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
  guard(:rspec, cmd:) do # rubocop:disable Metrics/BlockLength
    require 'guard/rspec/dsl'
    dsl = Guard::RSpec::Dsl.new(self)

    # Feel free to open issues for suggestions and improvements

    # RSpec files
    rspec = dsl.rspec
    watch(rspec.spec_helper) { rspec.spec_dir }
    watch(rspec.spec_support) { rspec.spec_dir }
    watch(rspec.spec_files)

    # Ruby files
    ruby = dsl.ruby
    dsl.watch_spec_files_for(ruby.lib_files)

    # Rails files
    rails = dsl.rails(view_extensions: %w[erb haml slim])
    dsl.watch_spec_files_for(rails.app_files)
    dsl.watch_spec_files_for(rails.views)

    watch(rails.controllers) do |m|
      [
        rspec.spec.call("routing/#{m[1]}_routing"),
        rspec.spec.call("controllers/#{m[1]}_controller"),
        rspec.spec.call("acceptance/#{m[1]}")
      ]
    end

    # Rails config changes
    watch(rails.spec_helper)     { rspec.spec_dir }
    watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
    watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }

    # Capybara features specs
    watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
    watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }

    # Turnip features and steps
    watch(%r{^spec/acceptance/(.+)\.feature$})
    watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
      Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance'
    end
  end
end

group :default do
  cmd = 'bundle exec rspec --format documentation'
  rspec_guard(cmd)
end

group :focus do
  cmd = 'bundle exec rspec --tag focus --format documentation'
  rspec_guard(cmd)
end

# app/services/salesforce_service.rb

require 'restforce'
require 'uri'
require 'net/http'

class SalesforceService
  attr_reader :access_token, :client

  def initialize
    @client = Restforce.new(
      client_id: Rails.application.credentials[:sf_consumer_key],
      client_secret: Rails.application.credentials[:sf_consumer_secret],
      host: Rails.application.credentials[:sf_host],
      api_version: '61.0'
    )
  end

  def sobjects
    @client.describe
  end

  def sobject_names
    sobjects.pluck('name')
  end

  def list_users
    @client.query('SELECT Id, Name FROM User')
  end

  def list_accounts
    @client.query('Select Id, Name FROM Account')
  end

  def find_account(id: nil, name: nil)
    if id
      @client.find('Account', id)
    elsif name
      @client.query("select Id,Name from Account where Name = '#{name}'")
    end
  end

  def create_account(name:)
    @client.create('Account', Name: name)
  end

  def delete_account(id:)
    @client.destroy('Account', id)
  end
end

require 'rails_helper'

RSpec.describe SalesforceService, type: :service do
  before do
    @service = described_class.new
  end

  describe 'Restforce Client' do
    before do
      @client = @service.client
    end

    it 'is not nil', focus: false do
      expect(@client).not_to be_nil
    end

    it 'can authenticate' do
      expect { @client.authenticate! }.not_to raise_error
    end

    it 'can execute a query to list users', focus: false do
      expect(@service.list_users.count).to be > 0
    end

    it 'can execute a query to list accounts', focus: false do
      res = @service.list_accounts
      puts res.first
      expect(res.count).to be > 0
    end

    it 'can find an account by Id', focus: false do
      id = '001ak00000W8ZRDAA3'
      name = 'Sample Account for Entitlements'
      res = @service.find_account(id:)
      expect(res['Id']).to eq(id)
      expect(res['Name']).to eq(name)
    end

    it 'can find an account by Name', focus: false do
      id = '001ak00000W8ZRDAA3'
      name = 'Sample Account for Entitlements'
      res = @service.find_account(name:).first
      expect(res['Id']).to eq(id)
      expect(res['Name']).to eq(name)
    end

    it 'can create and delete an account', focus: false do
      name = Faker::Company.name
      id = @service.create_account(name:)
      expect(id.length).to eq(18)
      res = @service.find_account(id:)
      expect(res['Id']).to eq(id)
      expect(res['Name']).to eq(name)
      @service.delete_account(id:)
      expect { @service.find_account(id:) }.to raise_error(Restforce::NotFoundError)
    end
  end

  describe 'Access Token' do
    before do
      @access_token = @service.request_access_token
    end

    it 'is 112 characters long' do
      puts @access_token
      expect(@access_token.length).to eq(112)
    end

    it 'matches a broad alphanumeric pattern' do
      expect(valid_token?(@access_token)).to be true
    end
  end

  def valid_token?(token)
    has_lowercase = token.match?(/[a-z]/)
    has_uppercase = token.match?(/[A-Z]/)
    has_number = token.match?(/\d/)
    has_special = token.match?(/[!@#$%^&*(),.?":{}|<>]/)

    has_lowercase && has_uppercase && has_number && has_special
  end
end