web47core 0.1.4 → 0.1.5

data/Rakefile

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-# Add your own tasks in files placed in lib/tasks ending in .rake,
-# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
-
-require_relative 'test/test_helper'
-Rails.application.load_tasks

data/bin/cron_server

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.join(Dir.getwd, 'config', 'environment')
-Cron::Command.new(ARGV).daemonize

data/test/controllers/status_controller_test.rb

@@ -1,158 +0,0 @@
-# require 'test_helper'
-# class StatusControllerTest < ActionDispatch::IntegrationTest
-#
-#   context 'mongo status' do
-#     should 'pass mongo' do
-#       SystemConfiguration.configuration
-#       get status_index_path
-#       assert_response :success
-#       assert_select 'table', 1 do |table|
-#         assert_select table, 'tbody', 1 do |body|
-#           assert_select body, 'tr[1]', 1 do |row|
-#             assert_select row, 'td[2]', 1 do |col|
-#               assert_select col, 'i', 'check_circle', col
-#             end
-#           end
-#         end
-#       end
-#     end
-#     should 'render json' do
-#       SystemConfiguration.configuration
-#       get "/status.json"
-#       assert_response :success
-#       json = JSON.parse(response.body)
-#       mongo = json['mongo']
-#       assert mongo['success'], mongo.inspect
-#       assert_equal '1 Configs', mongo['message'], mongo.inspect
-#     end
-#     should 'render text success' do
-#       Cron::Server.find_or_create_server.become_primary
-#       SystemConfiguration.configuration
-#       get "/status.text"
-#       assert_response :success
-#     end
-#     should 'fail mongo' do
-#       SystemConfiguration.destroy_all
-#       get status_index_path
-#       assert_response :success
-#       assert_select 'table', 1 do |table|
-#         assert_select table, 'tbody', 1 do |body|
-#           assert_select body, 'tr[1]', 1 do |row|
-#             assert_select row, 'td[2]', 1 do |col|
-#               assert_select col, "i", 'error', col
-#             end
-#           end
-#         end
-#       end
-#     end
-#     should 'render json fail' do
-#       SystemConfiguration.destroy_all
-#       get "/status.json"
-#       assert_response :success
-#       json = JSON.parse(response.body)
-#       mongo = json['mongo']
-#       refute mongo['success'], mongo.inspect
-#     end
-#     should 'render text fail' do
-#       SystemConfiguration.destroy_all
-#       get "/status.text"
-#       assert_response :internal_server_error
-#     end
-#   end
-#
-#   context 'redis status' do
-#     should 'pass redis' do
-#       get status_index_path
-#       assert_response :success
-#       # puts(response.body)
-#       assert_select 'table', 1 do |table|
-#         assert_select table, 'tbody', 1 do |body|
-#           assert_select body, 'tr[2]', 1 do |row|
-#             assert_select row, 'td[2]', 1 do |col|
-#               assert_select col, 'i', 'check_circle', col
-#             end
-#           end
-#         end
-#       end
-#     end
-#     should 'fail redis' do
-#       Rails.cache.expects(:write).once.raises('Redis not available')
-#       get status_index_path
-#       # Rails.cache.set 'redis-status-check', value
-#       assert_response :success
-#       assert_select 'table', 1 do |table|
-#         assert_select table, 'tbody', 1 do |body|
-#           assert_select body, 'tr[2]', 1 do |row|
-#             assert_select row, 'td[2]', 1 do |col|
-#               assert_select col, "i", 'error', col
-#             end
-#           end
-#         end
-#       end
-#     end
-#   end
-#
-#   context 'job count' do
-#     should 'display job count' do
-#       get status_index_path
-#       assert_response :success
-#       assert_select 'td', "#{Delayed::Backend::Mongoid::Job.count} Jobs", response.body
-#     end
-#   end
-#
-#   context 'cron job status' do
-#     should 'pass cron job' do
-#       server = Cron::Server.find_or_create_server
-#       server.become_primary
-#
-#       get status_index_path
-#       assert_response :success
-#       assert_select 'table', 1 do |table|
-#         assert_select table, 'tbody', 1 do |body|
-#           assert_select body, 'tr[4]', 1 do |row|
-#             assert_select row, 'td[2]', 1 do |col|
-#               assert_select col, 'i', 'check_circle', col
-#             end
-#             assert_select row, 'td[3]', 1 do |col|
-#               assert_select col, 'h4', "Primary Server is alive: #{server.host_name}(#{server.pid}), last check in #{server.last_check_in_at}", col
-#             end
-#           end
-#         end
-#       end
-#     end
-#     should 'fail cron job with dead primary server' do
-#       server = Cron::Server.find_or_create_server
-#       server.become_primary
-#       server.set last_check_in_at: 1.days.ago.utc
-#
-#       get status_index_path
-#       assert_response :success
-#       assert_select 'table', 1 do |table|
-#         assert_select table, 'tbody', 1 do |body|
-#           assert_select body, 'tr[4]', 1 do |row|
-#             assert_select row, 'td[2]', 1 do |col|
-#               assert_select col, 'i', 'error', col
-#             end
-#             assert_select row, 'td[3]', 1 do |col|
-#               assert_select col, 'h4', "Primary Server is DEAD: #{server.host_name}(#{server.pid}), last check in #{server.last_check_in_at}", col
-#             end
-#           end
-#         end
-#       end
-#     end
-#     should 'fail cron job' do
-#       Cron::Server.find_or_create_server
-#       get status_index_path
-#       assert_response :success
-#       assert_select 'table', 1 do |table|
-#         assert_select table, 'tbody', 1 do |body|
-#           assert_select body, 'tr[4]', 1 do |row|
-#             assert_select row, 'td[2]', 1 do |col|
-#               assert_select col, "i", 'error', col
-#             end
-#           end
-#         end
-#       end
-#     end
-#   end
-# end

data/test/factories/account_factories.rb

@@ -1,9 +0,0 @@
-#
-# Create basic accounts
-#
-FactoryBot.define do
-  # default account
-  factory :account, class: Account do
-    sequence(:name) { |n| "Account-#{n}" }
-  end
-end

data/test/factories/notification_factories.rb

@@ -1,14 +0,0 @@
-FactoryBot.define do
-
-  factory :notification, class: Notification do
-    to { "noone@app47.com" }
-    message { "None message" }
-  end
-
-  factory :email_notification, class: EmailNotification do
-    to { "noone@app47.com" }
-    sender { "someone@app47.com" }
-    subject { "here me roar!" }
-    message { "None message" }
-  end
-end

data/test/fixtures/mongoid.yml

@@ -1,8 +0,0 @@
-test:
-  clients:
-    default:
-      database: web47core_test
-      hosts:
-        - 127.0.0.1:27017
-      options:
-        max_pool_size: 1

data/test/fixtures/redis/host.yml

@@ -1,5 +0,0 @@
-test:
-  host: 127.0.0.1
-  port: 6378
-  db: 8
-  namespace: 'cache'

data/test/fixtures/redis/options.yml

@@ -1,8 +0,0 @@
-test:
-  host: 127.0.0.2
-  port: 6372
-  db: 7
-  connect_timeout: 0.2
-  read_timeout: 0.2
-  write_timeout: 0.2
-  timeout: 1

data/test/fixtures/redis/sentinel.yml

@@ -1,8 +0,0 @@
-test:
-  master: production
-  sentinels:
-    - host1:6379
-    - host2:6379
-    - host3:6379
-  role: master
-  namespace: 'cache'

data/test/fixtures/redis/url.yml

@@ -1,2 +0,0 @@
-test:
-  url: 'redis://localhost:6379/0'

data/test/jobs/cron/server_test.rb

@@ -1,160 +0,0 @@
-require 'test_helper'
-
-module Cron
-  class ServerTest < ActiveSupport::TestCase
-    context 'Delayed job counting' do
-      setup do
-        @server = Cron::Server.find_or_create_server
-        Delayed::Worker.delay_jobs = true
-      end
-      teardown do
-        Delayed::Worker.delay_jobs = false
-      end
-      should 'return zero' do
-        assert_equal 0, @server.delayed_jobs_count
-      end
-      should 'return three' do
-        3.times do
-          MockDelayedJob.new.background
-        end
-        assert_equal 3, @server.delayed_jobs_count
-      end
-      should 'return zero with failed job' do
-        MockDelayedJob.new.background
-        job = Delayed::Backend::Mongoid::Job.first
-        job.set failed_at: Time.now.utc
-        assert_equal 0, @server.delayed_jobs_count
-      end
-    end
-    context 'AutoScalingJob' do
-      setup do
-        @auto_scaling_group_name = 'redmonocle-testing-group'
-        @config = SystemConfiguration.first
-        @config.set(aws_access_key_id: 'access_key_id',
-                    aws_secret_access_key: 'secret_access_key',
-                    aws_region: 'region',
-                    aws_auto_scaling_group_name: @auto_scaling_group_name)
-      end
-      should 'not create any more instances if there are 1 - 249 jobs' do
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(49).at_least_once
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).never
-        Cron::Server.new.check_auto_scale
-      end
-      should 'create additional instances if there are 1,000 - 1,999 jobs and the number of instances currently running is less than the desired number of instances' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(0).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(51).at_least_once
-        params = { auto_scaling_group_name: @auto_scaling_group_name, min_size: 1, desired_capacity: 1 }
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).with(params).once
-        Cron::Server.new.check_auto_scale
-      end
-      should 'not create any additional instances if there are 1,000 - 1,999 jobs and the number of desired instances is less than or equal to the number of instances currently running' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(1).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(200).at_least_once
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).never
-        Cron::Server.new.check_auto_scale
-      end
-      should 'create additional instances if there are 2,000 - 2,999 jobs and the number of instances currently running is less than the desired number of instances' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(1).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(300).at_least_once
-        params = { auto_scaling_group_name: @auto_scaling_group_name, min_size: 2, desired_capacity: 2 }
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).with(params).once
-        Cron::Server.new.check_auto_scale
-      end
-      should 'not create any additional instances if there are 2,000 - 2,999 jobs and the number of desired instances is less than or equal to the number of instances currently running' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(3).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(750).at_least_once
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).never
-        Cron::Server.new.check_auto_scale
-      end
-      should 'create additional instances if there are 3,000 - 3,999 jobs and the number of instances currently running is less than the desired number of instances' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(1).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(300).at_least_once
-        params = { auto_scaling_group_name: @auto_scaling_group_name, min_size: 2, desired_capacity: 2 }
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).with(params).once
-        Cron::Server.new.check_auto_scale
-      end
-      should 'not create any additional instances if there are 3,000 - 3,999 jobs and the number of desired instances is less than or equal to the number of instances currently running' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(5).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(3_000).at_least_once
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).never
-        Cron::Server.new.check_auto_scale
-      end
-      should 'create additional instances if there are 4,000 jobs or more and the number of instances currently running is less than the desired number of instances' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(1).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(700).at_least_once
-        params = { auto_scaling_group_name: @auto_scaling_group_name, min_size: 3, desired_capacity: 3 }
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).with(params).once
-        Cron::Server.new.check_auto_scale
-      end
-      should 'not create any additional instances if there are 4,000 jobs or more and the number of desired instances is less than or equal to the number of instances currently running' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(7).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(4_000).at_least_once
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).never
-        Cron::Server.new.check_auto_scale
-      end
-      should 'remove all instances if there are no jobs left to run' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(7).at_least_once
-        Cron::Server.any_instance.expects(:delayed_jobs_count).returns(0).at_least_once
-        params = { auto_scaling_group_name: @auto_scaling_group_name, min_size: 0, desired_capacity: 0 }
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).with(params).once
-        Cron::Server.new.check_auto_scale
-      end
-      should 'create additional instances  by warming up a server' do
-        Cron::Server.any_instance.expects(:current_desired_capacity).returns(0).at_least_once
-        # Cron::Server.any_instance.expects(:delayed_jobs_count).returns(0).at_least_once
-        params = { auto_scaling_group_name: @auto_scaling_group_name, min_size: 1, desired_capacity: 1 }
-        Aws::AutoScaling::Client.any_instance.expects(:update_auto_scaling_group).with(params).once
-        Cron::Server.find_or_create_server.become_primary
-        Cron::Server.warm_up_server
-      end
-    end
-    context 'Run jobs' do
-      setup do
-        Cron::JobTab.ensure_cron_tabs
-        Cron::Tab.any_instance.expects(:time_to_run?).returns(true).at_least_once
-        Cron::TrimCronServers.expects(:perform_later).once
-        Cron::TrimNotifications.expects(:perform_later).once
-      end
-      should 'run jobs' do
-        assert_nothing_raised do
-          Cron::Server.find_or_create_server.execute
-        end
-      end
-    end
-    context 'Highlander' do
-      setup do
-        @s1 = Cron::Server.create! host_name: 's1', pid: '1123'
-        @s2 = Cron::Server.create! host_name: 's2', pid: '1124'
-        @s3 = Cron::Server.create! host_name: 's3', pid: '1125'
-        @s4 = Cron::Server.create! host_name: 's4', pid: '1126'
-      end
-      should 'allow one to become primary' do
-        assert_nothing_raised { @s1.become_primary }
-        assert_equal 1, Cron::Server.where(state: 'primary').count
-      end
-      should 'prevent second primary' do
-        assert_nothing_raised { @s1.become_primary }
-        refute @s2.update_attributes state: 'primary'
-        assert_equal 1, Cron::Server.where(state: 'primary').count
-      end
-      should 'determine to be alive ' do
-        server = Cron::Server.new host_name: 's1', pid: '1123', last_check_in_at: Time.now.utc
-        assert server.alive?
-        refute server.dead?
-      end
-      should 'determine to be dead' do
-        server = Cron::Server.new host_name: 's1', pid: '1123', last_check_in_at: 2.minutes.ago
-        refute server.alive?
-        assert server.dead?
-      end
-    end
-  end
-end
-
-class MockDelayedJob
-  def background
-
-  end
-
-  handle_asynchronously :background
-end

data/test/jobs/cron/switchboard_sync_configuration_test.rb

@@ -1,64 +0,0 @@
-require 'test_helper'
-
-module Cron
-  class SwitchboardSyncConfigurationTest < ActiveSupport::TestCase
-    setup do
-      @config = SystemConfiguration.configuration
-    end
-
-    context 'valid_environment?' do
-      should 'not run' do
-        refute Cron::SwitchboardSyncConfiguration.valid_environment?
-      end
-
-      should 'run' do
-        @config.switchboard_stack_api_token = 'abc123'
-        @config.switchboard_stack_id = 'abc123'
-        assert @config.save
-        assert Cron::SwitchboardSyncConfiguration.valid_environment?
-      end
-    end
-
-    context 'update system configuration' do
-      setup do
-        @config.switchboard_base_url = 'https://switchboard.test.com'
-        @config.switchboard_stack_api_token = 'abc124w'
-        @config.switchboard_stack_id = 'sid'
-        assert @config.save
-      end
-
-      should 'update system configuration' do
-        stub = stub_request(:get, "#{SystemConfiguration.switchboard_base_url}/stacks/sid/items.json").to_return(status: 200, body: { results: { cdn_url: 'https://cdn.nowhere.com' } }.to_json)
-        Cron::SwitchboardSyncConfiguration.new.perform
-        assert_not_nil @config.reload
-        assert_equal 'https://cdn.nowhere.com', @config.cdn_url
-        assert_requested stub
-      end
-
-      should 'update crontab' do
-        App47Logger.expects(:log_debug).once
-        Cron::JobTab.ensure_cron_tabs
-        tab = Cron::JobTab.find_by name: 'switchboard_sync_models'
-        assert_equal '0 0 * * *', tab.to_string
-        stub = stub_request(:get, "#{SystemConfiguration.switchboard_base_url}/stacks/sid/items.json").to_return(status: 200, body: { results: { switchboard_sync_models_crontab: '1 2 3 4 5' } }.to_json)
-        Cron::SwitchboardSyncConfiguration.new.perform
-        assert_not_nil tab.reload
-        assert_equal '1 2 3 4 5', tab.to_string
-        assert_requested stub
-      end
-      should 'deal with unknown' do
-        App47Logger.expects(:log_debug).never
-        App47Logger.expects(:log_warn).once
-        Cron::JobTab.ensure_cron_tabs
-        tab = Cron::JobTab.find_by name: 'switchboard_sync_models'
-        assert_equal '0 0 * * *', tab.to_string
-        stub = stub_request(:get, "#{SystemConfiguration.switchboard_base_url}/stacks/sid/items.json").to_return(status: 200, body: { results: { sync_knowledge_base_job_crontab: '1 2 3 4 5' } }.to_json)
-        Cron::SwitchboardSyncConfiguration.new.perform
-        assert_nil Cron::JobTab.where(name: 'sync_knowledge_base_job_crontab').first
-        assert_not_nil tab.reload
-        assert_equal '0 0 * * *', tab.to_string
-        assert_requested stub
-      end
-    end
-  end
-end