roqua-support 0.4.2 → 0.4.5

data/spec/roqua/scheduling/scheduler_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-require 'timecop'
-
-describe Roqua::Scheduling::Scheduler do
-  before do
-    Timecop.freeze
-    Roqua::Scheduling::CronJob.delete_all
-  end
-
-  after { Timecop.return }
-
-  subject { described_class.new }
-
-  def setup_daily_and_hourly_schedule
-    Roqua::Scheduling::Schedule.setup do |cron|
-      cron.add_task 'hourly', next_run_at: Roqua::Scheduling::Schedule::BEGINNING_OF_EVERY_HOUR do
-      end
-
-      cron.add_task 'daily', next_run_at: Roqua::Scheduling::Schedule::BEGINNING_OF_EVERY_DAY do
-      end
-    end
-  end
-
-  def setup_hourly_schedule
-    Roqua::Scheduling::Schedule.setup do |cron|
-      cron.add_task 'hourly', next_run_at: Roqua::Scheduling::Schedule::BEGINNING_OF_EVERY_HOUR do
-      end
-    end
-  end
-
-  it 'creates the correct table rows' do
-    expect { setup_daily_and_hourly_schedule }
-      .to change { Roqua::Scheduling::CronJob.all.pluck(:name, :next_run_at, :completed_at) }
-      .from(
-        []
-      )
-      .to(
-        [
-          ['hourly', Time.now.beginning_of_hour + 1.hour, nil],
-          ['daily', Time.now.beginning_of_day + 1.day, nil]
-        ]
-      )
-  end
-
-  it 'removes unused table rows' do
-    setup_daily_and_hourly_schedule
-
-    expect { setup_hourly_schedule }
-      .to change { Roqua::Scheduling::CronJob.all.pluck(:name).sort }
-      .from(['daily', 'hourly']).to(['hourly'])
-  end
-
-  it 'generates a database specific advisory lock name' do
-    # expect(ActiveRecord::Base.connection_config[:database]).to eql(':memory:')
-    expect(subject.advisory_lock_name).to eql ':memory:_cron_lock'
-  end
-
-  describe 'with a run_at in the future' do
-    before do
-      Roqua::Scheduling::Schedule.setup do |cron|
-        cron.add_task 'hourly', next_run_at: proc { 1.minute.from_now } do
-        end
-      end
-    end
-
-    it 'the task will not be run' do
-      expect(subject.schedule.tasks['hourly']).to_not receive(:run)
-      subject.ping
-    end
-  end
-
-  describe 'callbacks' do
-    let(:callback_spy) { spy(:callback) }
-
-    before do
-      Roqua::Scheduling::Schedule.setup do |cron|
-        cron.add_task 'hourly', next_run_at: proc { 1.minute.ago } do
-          callback_spy.execute
-        end
-      end
-    end
-
-    it 'get executed' do
-      expect(callback_spy).to receive(:execute)
-      subject.ping
-    end
-
-    it 'counts task calls' do
-      expect(Appsignal).to receive(:increment_counter).with('scheduler.completed', 1)
-      expect(Appsignal).to receive(:increment_counter).with('scheduler.run_task.completed', 1, task_name: 'hourly')
-      subject.ping
-    end
-  end
-
-  describe 'when running multiple times' do
-    before do
-      Timecop.freeze(60.seconds.ago)
-
-      Roqua::Scheduling::Schedule.setup do |cron|
-        cron.add_task 'task', next_run_at: proc { 30.seconds.from_now } do
-        end
-      end
-    end
-
-    let(:schedule) { Roqua::Scheduling::Schedule.current_schedule }
-
-    it 'the task is only called once' do
-      expect(schedule.tasks['task']).to receive(:run).once
-
-      Timecop.return
-      3.times { Roqua::Scheduling::Scheduler.new.ping }
-    end
-  end
-end

data/spec/roqua/status_checks/check_db_connection_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe 'Roqua::StatusChecks::CheckDbConnection' do
-  it 'returns true when there is a db connection' do
-    expect(Roqua::StatusChecks::CheckDbConnection.connected?).to be_truthy
-  end
-
-  it 'returns false when there is no db configured' do
-    allow(ActiveRecord::Base).to receive_message_chain(:connection, :active?).and_return(false)
-    expect(Roqua::StatusChecks::CheckDbConnection.connected?).to be_falsey
-  end
-end

data/spec/roqua/status_checks/check_load_balancer_member_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe 'Roqua::StatusChecks::CheckLoadBalancerMember' do
-  it 'returns true when the status file contains on' do
-    allow(File).to receive(:read).and_return('on')
-
-    expect(Roqua::StatusChecks::CheckLoadBalancerMember.balancer_member?('foo/bar')).to be_truthy
-  end
-
-  it 'returns false when the status file does not contain off' do
-    allow(File).to receive(:read).and_return('off')
-
-    expect(Roqua::StatusChecks::CheckLoadBalancerMember.balancer_member?('foo/bar')).to be_falsey
-  end
-
-  it 'raises InvalidStatus error when the status file contains something else' do
-    allow(File).to receive(:read).and_return('foo')
-
-    expect { Roqua::StatusChecks::CheckLoadBalancerMember.balancer_member?('foo/bar') }
-      .to raise_error(Roqua::StatusChecks::CheckLoadBalancerMember::InvalidStatus, 'Invalid state: foo')
-  end
-end

data/spec/roqua/status_checks/status_controller_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe Roqua::StatusChecks::StatusController, type: :controller do
-  context 'visiting the status page while balancer member and database is up' do
-    it 'returns the correct status' do
-      allow(Roqua::StatusChecks::CheckLoadBalancerMember).to receive(:balancer_member?).and_return(true)
-      allow(Roqua::StatusChecks::CheckDbConnection).to receive(:connected?).and_return(true)
-
-      get :balancer_status
-
-      expect(response.status).to eq(200)
-      expect(response.body).to eq("{\"status\":\"ok\",\"member\":true}")
-    end
-  end
-
-  context 'visiting the status page while not balancer member and database is up' do
-    it 'returns the correct status' do
-      allow(Roqua::StatusChecks::CheckLoadBalancerMember).to receive(:balancer_member?).and_return(false)
-      allow(Roqua::StatusChecks::CheckDbConnection).to receive(:connected?).and_return(true)
-
-      get :balancer_status
-
-      expect(response.status).to eq(503)
-      expect(response.body).to eq("{\"status\":\"ok\",\"member\":false}")
-    end
-  end
-
-  context 'visiting the status page while balancer member and database is down' do
-    it 'returns the correct status' do
-      allow(Roqua::StatusChecks::CheckLoadBalancerMember).to receive(:balancer_member?).and_return(true)
-      allow(Roqua::StatusChecks::CheckDbConnection).to receive(:connected?).and_return(false)
-
-      get :balancer_status
-
-      expect(response.status).to eq(503)
-      expect(response.body).to eq("{\"status\":\"error\",\"member\":true}")
-    end
-  end
-
-  context 'visiting the status page while not balancer member and database is down' do
-    it 'returns the correct status' do
-      allow(Roqua::StatusChecks::CheckLoadBalancerMember).to receive(:balancer_member?).and_return(false)
-      allow(Roqua::StatusChecks::CheckDbConnection).to receive(:connected?).and_return(false)
-
-      get :balancer_status
-
-      expect(response.status).to eq(503)
-      expect(response.body).to eq("{\"status\":\"error\",\"member\":false}")
-    end
-  end
-
-  context 'visiting the status page while balancer_state is on nor off' do
-    it 'returns the correct status' do
-      allow(Roqua::StatusChecks::CheckLoadBalancerMember).to receive(:balancer_member?)
-        .and_raise(Roqua::StatusChecks::CheckLoadBalancerMember::InvalidStatus)
-
-      get :balancer_status
-
-      expect(response.status).to eq(500)
-      expect(response.body).to eq("{\"status\":\"unknown status\"}")
-    end
-  end
-end

data/spec/roqua/support/errors_spec.rb

@@ -1,169 +0,0 @@
-require 'spec_helper'
-require 'roqua/support/errors'
-require 'appsignal'
-
-describe 'Error reporting' do
-  let(:exception) do
-    Exception.new('exception_message').tap do |exception|
-      exception.set_backtrace ['back', 'trace', 'lines']
-    end
-  end
-
-  let(:logstream)  { StringIO.new }
-  let(:logger)     { Logger.new(logstream) }
-  let(:logwrapper) { Roqua::LogWrapper.new(logger) }
-
-  before do
-    Rails.env = 'foo' # in test we don't log
-    Roqua.logger = logwrapper
-  end
-
-  context 'when the Roqua logger is defined' do
-    it 'supports default extra params' do
-      allow(Roqua::Support::Errors).to receive(:extra_parameters).and_return(organization: 'some_org')
-      expect(Roqua.logger).to receive(:error).with('roqua.exception',
-                                                   class_name: 'Exception',
-                                                   message: 'exception_message',
-                                                   backtrace: ['back', 'trace', 'lines'],
-                                                   parameters: {organization: 'some_org'})
-      Roqua::Support::Errors.report exception
-    end
-
-    it 'sends notifications to the eventlog' do
-      expect(Roqua.logger).to receive(:error).with('roqua.exception',
-                                                   class_name: 'Exception',
-                                                   message: 'exception_message',
-                                                   backtrace: ['back', 'trace', 'lines'],
-                                                   parameters: {})
-      Roqua::Support::Errors.report exception
-    end
-
-    it 'skips the backtrace when the skip_backtrace flag is set' do
-      expect(Roqua.logger).to receive(:error).with('roqua.exception',
-                                                   class_name: 'Exception',
-                                                   message: 'exception_message',
-                                                   parameters: {})
-      Roqua::Support::Errors.report exception, skip_backtrace: true
-    end
-
-    it 'can add extra parameters by calling add_parameters' do
-      expect(Roqua.logger).to receive(:error).with \
-        'roqua.exception', class_name: 'RuntimeError',
-                           message: 'exception_message',
-                           parameters: {more: 'params',
-                                        even_more: 'params'}
-      begin
-        begin
-          begin
-            fail 'exception_message'
-          rescue
-            Roqua::Support::Errors.add_parameters(more: 'params')
-            raise
-          end
-        rescue
-          Roqua::Support::Errors.add_parameters(even_more: 'params')
-          raise
-        end
-      rescue => e
-        Roqua::Support::Errors.report e, skip_backtrace: true
-      end
-    end
-
-    it 'will not fail when called outside of rescue or when passed the wrong format to add_parameters' do
-      expect(Roqua.logger).to receive(:error).with \
-        'roqua.exception', class_name: 'RuntimeError',
-                           message: 'exception_message',
-                           parameters: {}
-
-      begin
-        Roqua::Support::Errors.add_parameters('just a string')
-        begin
-          fail 'exception_message'
-        rescue
-          Roqua::Support::Errors.add_parameters('just a string')
-          raise
-        end
-      rescue => e
-        Roqua::Support::Errors.report e, skip_backtrace: true
-      end
-    end
-  end
-
-  context 'when Appsignal is loaded' do
-    let(:agent)       { double("agent") }
-    let(:transaction) { double("transaction") }
-
-    before do
-      Appsignal.config = Appsignal::Config.new(Dir.pwd, "test")
-      allow(Appsignal).to receive(:active?).and_return(true)
-      allow(Appsignal).to receive(:is_ignored_exception?).and_return(false)
-      allow(Appsignal).to receive(:agent).and_return(agent)
-    end
-
-    it 'it will send an error' do
-      expect(Appsignal).to receive(:send_error)
-      Roqua::Support::Errors.report exception
-    end
-
-    it 'defaults to a background job' do
-      transaction = Appsignal::Transaction.new(SecureRandom.uuid, Appsignal::Transaction::FRONTEND, nil)
-      expect(Appsignal).to receive(:send_error).with(exception).and_yield(transaction)
-      Roqua::Support::Errors.report exception
-      expect(transaction.namespace).to eq Appsignal::Transaction::BACKGROUND_JOB
-    end
-
-    it 'it will send an error under the provided category' do
-      transaction = Appsignal::Transaction.new(SecureRandom.uuid, Appsignal::Transaction::FRONTEND, nil)
-      expect(Appsignal)
-        .to receive(:send_error)
-        .with(exception).and_yield(transaction)
-
-      Roqua::Support::Errors.report exception, a: 'b', namespace: :web
-      expect(transaction.namespace).to eq Appsignal::Transaction::HTTP_REQUEST
-      expect(transaction.tags).to eq a: 'b'
-    end
-
-    describe 'when a current transaction is present' do
-      let(:current_transaction) do
-        Appsignal::Transaction.new(SecureRandom.uuid, Appsignal::Transaction::HTTP_REQUEST, nil)
-      end
-
-      before do
-        expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(current_transaction)
-      end
-
-      it 'sets the correct properties if a current transaction is present' do
-        expect(current_transaction).to receive(:set_tags).with(a: 'b').and_call_original
-        expect(current_transaction).to receive(:add_exception).with(exception).and_call_original
-
-        Roqua::Support::Errors.report exception, a: 'b', namespace: :web
-      end
-
-      describe "if the current transaction isn't a http request" do
-        let(:current_transaction) do
-          Appsignal::Transaction.new(SecureRandom.uuid, Appsignal::Transaction::BACKGROUND_JOB, nil)
-        end
-
-        it "will not set the properties if the current transaction isn't a http request" do
-          expect(current_transaction).to_not receive(:set_tags)
-          expect(current_transaction).to_not receive(:add_exception)
-
-          Roqua::Support::Errors.report exception, a: 'b', namespace: :web
-        end
-      end
-    end
-  end
-
-  context '.appsignal_namespace_for_category' do
-    it 'returns the correct string based on the category' do
-      expect(Roqua::Support::Errors.appsignal_namespace_for_category(:background))
-        .to eql(Appsignal::Transaction::BACKGROUND_JOB)
-
-      expect(Roqua::Support::Errors.appsignal_namespace_for_category(:web))
-        .to eql(Appsignal::Transaction::HTTP_REQUEST)
-
-      expect(Roqua::Support::Errors.appsignal_namespace_for_category(''))
-        .to eql(Appsignal::Transaction::BLANK)
-    end
-  end
-end

data/spec/roqua/support/helpers_spec.rb

@@ -1,50 +0,0 @@
-require 'roqua/support/instrumentation'
-
-describe 'Helper methods' do
-  describe '#with_instrumentation' do
-    include Roqua::Support::Instrumentation
-
-    let(:logger) { double("Logger", info: nil, error: nil) }
-    let(:stats)  { double("Stats", submit: nil) }
-
-    before do
-      allow(Roqua).to receive(:logger).and_return(logger)
-      allow(Roqua).to receive(:stats).and_return(stats)
-    end
-
-    context 'when the block returns a value' do
-      it 'logs the start and finish lifecycle of a block' do
-        expect(logger).to receive(:info).with('testevent:started', {extra: "params"}).ordered
-        expect(logger).to receive(:info).with('testevent:finished', hash_including({extra: "params"})).ordered
-        expect(stats).to receive(:submit).with('testevent.finished', 1)
-        expect(stats).to receive(:submit).with('testevent.duration', an_instance_of(Float))
-
-        with_instrumentation('testevent', extra: 'params') { 1 + 1 }
-      end
-
-      it 'returns the value returned by the block' do
-        expect(with_instrumentation('testevent') { 1 + 1 }).to eq 2
-      end
-    end
-
-    context 'when an exception happens during the block' do
-      it 'logs the start and failure of a block if it raises' do
-        expect(logger).to receive(:info).with('testevent:started', instance_of(Hash)).ordered
-        expect(logger).to receive(:error).with('testevent:failed', instance_of(Hash)).ordered
-        expect(stats).to receive(:submit).with('testevent.failed', 1)
-
-        with_instrumentation 'testevent' do
-          raise StandardError, "Foo"
-        end rescue nil
-      end
-
-      it 'reraises the exception' do
-        expect {
-          with_instrumentation 'testevent' do
-            raise "Foo"
-          end
-        }.to raise_error('Foo')
-      end
-    end
-  end
-end

data/spec/roqua/support/logwrapper_spec.rb

@@ -1,69 +0,0 @@
-require 'roqua/support/log_wrapper'
-require 'logger'
-require 'stringio'
-
-module Roqua
-  describe LogWrapper do
-    before { allow(Roqua).to receive(:appname).and_return('roqua-support-testsuite') }
-
-    let(:logstream)  { StringIO.new }
-    let(:logger)     { Logger.new(logstream) }
-    let(:logwrapper) { LogWrapper.new(logger) }
-
-    def log
-      logstream.string
-    end
-
-    describe '#add' do
-      it 'writes event name to log' do
-        logwrapper.add :info, "testevent"
-        expect(log).to include("testevent {}\n")
-      end
-
-      it 'writes given parameters as json hash' do
-        logwrapper.add :info, "testevent", extra: 'params', go: 'here'
-        expect(log).to include('testevent {"extra":"params","go":"here"}' + "\n")
-      end
-
-      it 'escapes newline characters in params' do
-        logwrapper.add :info, "testevent", param: "this\nshould not have newlines"
-        expect(log).to include('testevent {"param":"this\nshould not have newlines"')
-      end
-    end
-
-    describe '#lifecycle' do
-      it 'logs the start and finish lifecycle of a block' do
-        logwrapper.lifecycle 'testevent', extra: 'params' do
-          1 + 1
-        end
-        expect(log).to include('testevent:started {"extra":"params"}')
-        expect(log).to match(/testevent:finished.*"extra":"params"/)
-      end
-
-      it 'logs the duration of the block with the finished event' do
-        logwrapper.lifecycle('testevent') { 1 + 1 }
-        expect(log).to match(/testevent:finished.*"duration":/)
-      end
-
-      it 'returns the value returned by the block' do
-        expect(logwrapper.lifecycle('testevent') { 1 + 1 }).to eq 2
-      end
-
-      it 'logs the start and failure of a block if it raises' do
-        logwrapper.lifecycle 'testevent' do
-          raise StandardError, "Foo"
-        end rescue nil
-        expect(log).to include('testevent:started')
-        expect(log).to include('testevent:failed {"exception":"StandardError","message":"Foo"}')
-      end
-
-      it 'reraises the exception' do
-        expect {
-          logwrapper.lifecycle 'testevent' do
-            raise "Foo"
-          end
-        }.to raise_error('Foo')
-      end
-    end
-  end
-end

data/spec/roqua/support/request_logger_spec.rb

@@ -1,148 +0,0 @@
-require 'roqua/support/log_wrapper'
-require 'roqua/support/request_logger'
-require 'active_support/notifications'
-require 'active_support/core_ext/string'
-
-describe Roqua::Support::RequestLogger do
-  let(:logstream)  { StringIO.new }
-  let(:logger)     { Logger.new(logstream) }
-  let(:logwrapper) { Roqua::LogWrapper.new(logger) }
-
-  # before { Roqua.stub(logger: logwrapper) }
-  before { allow(Roqua).to receive(:logger).and_return(logwrapper) }
-
-  def log
-    logstream.string
-  end
-
-  let(:subscriber) { Roqua::Support::RequestLogger.new }
-
-  context 'when processing a request' do
-    let(:event) do
-      ActiveSupport::Notifications::Event.new('process_action.action_controller',
-                                              Time.new(2013, 02, 28, 12, 34, 56),
-                                              Time.new(2013, 02, 28, 12, 34, 57), 2,
-          status: 200, format: 'application/json', method: 'GET', path: '/home?foo=bar',
-          params: {'controller' => 'home', 'action' => 'index', 'foo' => 'bar'},
-          db_runtime: 0.02, view_runtime: 0.01
-      )
-    end
-
-    it "logs the URL" do
-      subscriber.process_action(event)
-      expect(logstream.string).to include('/home')
-    end
-
-    it "does not log the query string" do
-      subscriber.process_action(event)
-      expect(logstream.string).to_not include('?foo=bar')
-    end
-
-    it "logs the HTTP method" do
-      subscriber.process_action(event)
-      expect(logstream.string).to include('"method":"GET"')
-    end
-
-    it "logs the status code returned" do
-      subscriber.process_action(event)
-      expect(logstream.string).to include('"status":200')
-    end
-
-    it "logs the controller and action" do
-      subscriber.process_action(event)
-      expect(logstream.string).to include('"controller":"home","action":"index"')
-    end
-
-    it 'logs request parameters' do
-      subscriber.process_action(event)
-      expect(logstream.string).to include('"params":{"foo":"bar"}')
-    end
-
-    it "logs how long the request took" do
-      subscriber.process_action(event)
-      expect(logstream.string).to match /"duration":1000.0/
-    end
-
-    it "logs the view rendering time" do
-      subscriber.process_action(event)
-      expect(logstream.string).to match /"view":0.01/
-    end
-
-    it "logs the database rendering time" do
-      subscriber.process_action(event)
-      expect(logstream.string).to match /"db":0.02/
-    end
-
-    it 'logs extra information added in the controller' do
-      controller = Class.new do
-        include Roqua::Support::RequestLogging
-
-        def index
-          add_log_information 'current_user', 'johndoe'
-        end
-      end
-      controller.new.index
-      subscriber.process_action(event)
-      expect(logstream.string).to include('"current_user":"johndoe"')
-
-      # next request should not still maintain this data
-      logstream.truncate 0
-      subscriber.process_action(event)
-      expect(logstream.string).to_not include('current_user')
-    end
-  end
-
-  context 'when an exception occured processing the request' do
-    let(:event) do
-      ActiveSupport::Notifications::Event.new('process_action.action_controller',
-                                              Time.now, Time.now, 2,
-          status: nil, format: 'application/json', method: 'GET', path: '/home?foo=bar',
-          exception: ['AbstractController::ActionNotFound', 'Route not found'],
-          params: {'controller' => 'home', 'action' => 'index', 'foo' => 'bar'},
-          db_runtime: 0.02, view_runtime: 0.01
-      )
-    end
-
-    it "logs the 500 status when an exception occurred" do
-      subscriber.process_action(event)
-      expect(logstream.string).to match /"status":500/
-      expect(logstream.string).to match /"error":"AbstractController::ActionNotFound:Route not found"/
-    end
-
-    it "should return an unknown status when no status or exception is found" do
-      event.payload[:status] = nil
-      event.payload[:exception] = nil
-      subscriber.process_action(event)
-      expect(logstream.string).to match /"status":0/
-    end
-  end
-
-  context 'when the request redirected' do
-    let(:event) do
-      ActiveSupport::Notifications::Event.new('process_action.action_controller',
-                                              Time.new(2013, 02, 28, 12, 34, 56),
-                                              Time.new(2013, 02, 28, 12, 34, 57), 2,
-          status: 200, format: 'application/json', method: 'GET', path: '/home?foo=bar',
-          params: {'controller' => 'home', 'action' => 'index', 'foo' => 'bar'},
-          db_runtime: 0.02, view_runtime: 0.01
-      )
-    end
-
-    let(:redirect) {
-      ActiveSupport::Notifications::Event.new(
-        'redirect_to.action_controller', Time.now, Time.now, 1, location: 'http://example.com', status: 302
-      )
-    }
-
-    it 'logs the redirect' do
-      subscriber.redirect_to(redirect)
-      subscriber.process_action(event)
-      expect(log).to include('"location":"http://example.com"')
-
-      # next request should no longer get location
-      logstream.truncate 0
-      subscriber.process_action(event)
-      expect(log).to_not include('location')
-    end
-  end
-end

data/spec/roqua/support/stats_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-require 'roqua/support/stats'
-
-describe 'Stats' do
-  let(:backend) { double("StatsBackend") }
-  let(:stats)   { Roqua::Support::Stats.new(backend) }
-
-  before do
-    Roqua.appname = 'appname'
-  end
-
-  describe 'tracking a value' do
-    it 'reports to backend' do
-      expect(backend).to receive(:submit).with('appname.data_export.duration', 2.3)
-      stats.submit('data_export.duration', 2.3)
-    end
-  end
-end

data/spec/roqua/support_spec.rb

@@ -1,19 +0,0 @@
-require 'roqua/support'
-
-describe Roqua do
-  describe '#logger' do
-    it 'has a default' do
-      expect(Roqua.logger).to be_an_instance_of(Roqua::LogWrapper)
-    end
-  end
-
-  describe '#logger=' do
-    let(:logger) { double }
-
-    it 'wraps a given logger' do
-      Roqua.logger = logger
-      expect(Roqua.logger).to be_an_instance_of(Roqua::LogWrapper)
-      expect(Roqua.logger.logger).to eq logger
-    end
-  end
-end