cosmos 4.5.2 → 5.0.2.pre.beta2

data/lib/cosmos/dart/spec/dart/dart_reducer_manager_spec.rb

@@ -1,290 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'rails_helper'
-require 'dart_reducer_manager'
-require 'database_cleaner'
-require 'dart_packet_log_writer'
-require 'dart_decommutator'
-require 'dart_common'
-
-describe DartReducerManager do
-  let(:common) { Object.new.extend(DartCommon) }
-
-  before(:each) do
-    DatabaseCleaner.strategy = :truncation
-    DatabaseCleaner.clean
-    Rails.application.load_seed
-  end
-
-  def setup_ples(entries, delta_time)
-    time = Time.utc(2018, 1, 1, 0, 0, 0)
-    meta = Cosmos::System.telemetry.packet("SYSTEM", "META")
-    meta.received_time = time
-    hs_packet = Cosmos::System.telemetry.packet("INST", "HEALTH_STATUS")
-    # 128 byte file header, SYSTEM META has 15 byte header + length of SYSTEM & META
-    # INST HEALTH_STATUS has 15 byte header + length of INST & HEALTH_STATUS
-    length = 128 + 25 + meta.length + entries * (32 + hs_packet.length)
-
-    writer = DartPacketLogWriter.new(
-      :TLM,    # Log telemetry
-      'test_decom_', # File name suffix
-      true,    # Enable logging
-      nil,     # Don't cycle on time
-      length, # Cycle the log after a single INST HEALTH_STATUS packet
-      Cosmos::System.paths['DART_DATA']) # Log into the DART_DATA dir
-
-    entries.times do |x|
-      hs_packet.received_time = time
-      hs_packet.write("COLLECTS", x)
-      writer.write(hs_packet)
-      time += delta_time
-    end
-    ples = 0
-    count = 0
-    writer.shutdown
-    while ples != (entries + 1) # SYSTEM META is the plus 1
-      ples = PacketLogEntry.count
-      sleep 0.1 # Allow the log writer to work
-      count += 1
-      break if count == 100 # 10s
-    end
-    sleep 0.1
-    expect(count).to be < 100
-
-    thread = Thread.new do
-      decom = DartDecommutator.new
-      decom.run
-    end
-    complete = 0
-    count = 0
-    while complete != (entries + 1) # SYSTEM META is the plus 1
-      complete = PacketLogEntry.where("decom_state = #{PacketLogEntry::COMPLETE}").length
-      sleep 0.1 # Allow the decommutator to work
-      count += 1
-      break if count == 200 # 20s
-    end
-    expect(count).to be < 200
-    thread.kill
-  end
-
-  def worker_threads
-    count = 0
-    Thread.list.each do |t|
-      count += 1 if t.inspect.include?("worker_thread")
-    end
-    count
-  end
-
-  def get_mappings(tgt, pkt, item)
-    target_model = Target.where("name = ?", tgt).first
-    packet_model = Packet.where("target_id = ? and name = ? and is_tlm = ?", target_model.id, pkt, true).first
-    item_model = Item.where("packet_id = ? and name = ?", packet_model.id, item).first
-    mappings = ItemToDecomTableMapping.where("item_id = ? and value_type != ?", item_model.id, ItemToDecomTableMapping::RAW)
-  end
-
-  describe "run" do
-    it "starts the specified number of worker threads" do
-      drm = DartReducerManager.new(1)
-      thread = Thread.new { drm.run }
-      sleep 0.1
-      expect(worker_threads()).to eq 1
-      drm.shutdown
-      thread.kill
-
-      drm = DartReducerManager.new(5)
-      thread = Thread.new { drm.run }
-      sleep 0.1
-      expect(worker_threads()).to eq 5
-      drm.shutdown
-      thread.kill
-    end
-
-    it "reduces per minute" do
-      setup_ples(11, 6) # 11 entries with a 6s gap
-      drm = DartReducerManager.new(1)
-      thread = Thread.new { drm.run }
-      sleep 0.5
-      drm.shutdown
-      thread.kill
-
-      get_mappings("INST", "HEALTH_STATUS", "COLLECTS").each do |mapping|
-        # Grab the base reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index)
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # The last one doesn't get reduced
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 1
-        # Everything else should be reduced
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 10
-        val = 0
-        rows.find_each do |row|
-          expect(row.read_attribute("i#{mapping.item_index}")).to eq val
-          val += 1
-        end
-
-        # Grab the minute reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index, "_m")
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # We only spanned a single minute so we have a single packet ready to reduce
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 1
-        # None have been actually reduced
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 0
-        rows.find_each do |row|
-          expect(row.num_samples).to eq 10
-          expect(row.read_attribute("i#{mapping.item_index}min")).to eq 0
-          expect(row.read_attribute("i#{mapping.item_index}max")).to eq 9
-          expect(row.read_attribute("i#{mapping.item_index}avg")).to eq ((0..9).to_a.sum / 10.0)
-          expect(row.read_attribute("i#{mapping.item_index}stddev")).to be_within(0.0000001).of(Math.stddev_population((0..9).to_a)[1])
-        end
-      end
-    end
-
-    it "reduces per hour" do
-      # 367 entries at 10s apart creates 3670.367s which is 1hr, 1min and 10s of time
-      # The extra 10s is due to the last one not getting reduced. The extra minute is due
-      # to the last minute reduction table not getting reduced.
-      setup_ples(367, 10.001)
-      drm = DartReducerManager.new(1)
-      thread = Thread.new { drm.run }
-      sleep 2
-      drm.shutdown
-      thread.kill
-
-      get_mappings("INST", "HEALTH_STATUS", "COLLECTS").each do |mapping|
-        # Grab the base reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index)
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # The last one doesn't get reduced
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 1
-        # Everything else should be reduced
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 366
-        val = 0
-        rows.find_each do |row|
-          expect(row.read_attribute("i#{mapping.item_index}")).to eq val
-          val += 1
-        end
-
-        # Grab the minute reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index, "_m")
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # The last one doesn't get reduced
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 1
-        # We reduced 60 minutes
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 60
-        row = rows.first
-        expect(row.num_samples).to eq 6
-        expect(row.read_attribute("i#{mapping.item_index}min")).to eq 0
-        expect(row.read_attribute("i#{mapping.item_index}max")).to eq 5
-        expect(row.read_attribute("i#{mapping.item_index}avg")).to eq ((0..5).to_a.sum / 6.0)
-        expect(row.read_attribute("i#{mapping.item_index}stddev")).to be_within(0.0000001).of(Math.stddev_population((0..5).to_a)[1])
-
-        # Grab the hour reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index, "_h")
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # We only spanned a single hour so we have a single packet ready to reduce
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 1
-        # None have been actually reduced
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 0
-        row = rows.first
-        expect(row.num_samples).to eq 60
-        expect(row.read_attribute("i#{mapping.item_index}min")).to eq 0
-        expect(row.read_attribute("i#{mapping.item_index}max")).to eq 359
-        expect(row.read_attribute("i#{mapping.item_index}avg")).to eq ((0..359).to_a.sum / 360.0)
-        expect(row.read_attribute("i#{mapping.item_index}stddev")).to be_within(0.05).of(Math.stddev_population((0..359).to_a)[1])
-      end
-    end
-
-    it "reduces per day" do
-      # 72 is three days plus the extra reduction, minute, and hour
-      setup_ples(75, 3600.001)
-      drm = DartReducerManager.new(1)
-      thread = Thread.new { drm.run }
-      sleep 2
-      drm.shutdown
-      thread.kill
-
-      drm = DartReducerManager.new(1)
-      thread = Thread.new { drm.run }
-      sleep 2
-      drm.shutdown
-      thread.kill
-
-      get_mappings("INST", "HEALTH_STATUS", "COLLECTS").each do |mapping|
-        # Grab the base reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index)
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # The last one doesn't get reduced
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 1
-        # Everything else should be reduced
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 74
-        val = 0
-        rows.find_each do |row|
-          expect(row.read_attribute("i#{mapping.item_index}")).to eq val
-          val += 1
-        end
-
-        # Grab the minute reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index, "_m")
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # The last one doesn't get reduced
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 1
-        # The rest is reduced
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 73
-        val = 0
-        rows.find_each do |row|
-          # Since our samples were more than 1 min apart there is only 1 sample per row
-          expect(row.num_samples).to eq 1
-          # Min, max, and avg are all the same since we only have 1 sample
-          expect(row.read_attribute("i#{mapping.item_index}min")).to eq val
-          expect(row.read_attribute("i#{mapping.item_index}max")).to eq val
-          expect(row.read_attribute("i#{mapping.item_index}avg")).to eq val
-          expect(row.read_attribute("i#{mapping.item_index}stddev")).to eq 0
-          val += 1
-        end
-
-        # Grab the hour reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index, "_h")
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # The last one doesn't get reduced
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 1
-        # The rest is reduced
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 72
-        val = 0
-        rows.find_each do |row|
-          # Since our samples were more than 1 hour apart there is only 1 sample per row
-          expect(row.num_samples).to eq 1
-          # Min, max, and avg are all the same since we only have 1 sample
-          expect(row.read_attribute("i#{mapping.item_index}min")).to eq val
-          expect(row.read_attribute("i#{mapping.item_index}max")).to eq val
-          expect(row.read_attribute("i#{mapping.item_index}avg")).to eq val
-          expect(row.read_attribute("i#{mapping.item_index}stddev")).to eq 0
-          val += 1
-        end
-
-        # Grab the day reduction table
-        rows = common.get_decom_table_model(mapping.packet_config_id, mapping.table_index, "_d")
-        expect(rows.where("reduced_state" => DartCommon::INITIALIZING).count).to eq 0
-        # Day values are always "READY" since they don't get further reduced
-        expect(rows.where("reduced_state" => DartCommon::READY_TO_REDUCE).count).to eq 3
-        # Reduced is always 0
-        expect(rows.where("reduced_state" => DartCommon::REDUCED).count).to eq 0
-        val = 0
-        rows.find_each do |row|
-          expect(row.num_samples).to eq 24
-          expect(row.read_attribute("i#{mapping.item_index}min")).to eq val
-          expect(row.read_attribute("i#{mapping.item_index}max")).to eq val + 23
-          expect(row.read_attribute("i#{mapping.item_index}avg")).to eq ((val..(val+23)).to_a.sum / 24.0)
-          expect(row.read_attribute("i#{mapping.item_index}stddev")).to be_within(0.0000001).of(Math.stddev_population((val..(val+23)).to_a)[1])
-          val += 24
-        end
-      end
-    end
-  end
-end

data/lib/cosmos/dart/spec/dart/dart_tcpip_server_interface_spec.rb

@@ -1,240 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'rails_helper'
-require 'dart_tcpip_server_interface'
-require 'packet_log_entry'
-require 'dart_packet_log_writer'
-
-describe DartTcpipServerInterface do
-  before(:all) do
-    @request = Cosmos::Packet.new('DART', 'DART')
-    @request.define_item('REQUEST', 0, 0, :BLOCK)
-  end
-
-  before(:each) do
-    DatabaseCleaner.strategy = :truncation
-    DatabaseCleaner.clean
-    Rails.application.load_seed
-  end
-
-  describe "initialize" do
-    it "uses the System.ports['DART_STREAM']" do
-      i = DartTcpipServerInterface.new
-      expect(i.instance_variable_get(:@read_port)).to eq Cosmos::System.ports['DART_STREAM']
-      expect(i.instance_variable_get(:@write_port)).to eq Cosmos::System.ports['DART_STREAM']
-      expect(i.listen_address).to eq Cosmos::System.listen_hosts['DART_STREAM']
-    end
-  end
-
-  describe "write" do
-    it "drops connection on bad request packets" do
-      Cosmos::Logger.level = Cosmos::Logger::INFO
-      i = DartTcpipServerInterface.new
-      i.connect
-
-      interface = Cosmos::TcpipClientInterface.new(
-        Cosmos::System.connect_hosts['DART_STREAM'],
-        Cosmos::System.ports['DART_STREAM'],
-        Cosmos::System.ports['DART_STREAM'],
-        10, 10, 'PREIDENTIFIED')
-      interface.connect
-      @request.write('REQUEST', "BLAH")
-      interface.write(@request)
-      sleep 0.1
-      i.disconnect
-
-      Dir["#{Cosmos::System.paths['DART_LOGS']}/*"].each do |file|
-        expect(file).to match(/dart_stream_server/)
-        expect(File.read(file)).to include("lost read connection")
-      end
-    end
-  end
-
-  def load_db(num_pkts)
-    writer = DartPacketLogWriter.new(
-      :TLM,    # Log telemetry
-      'test_decom_', # File name suffix
-      true,    # Enable logging
-      nil,     # Don't cycle on time
-      2_000_000_000, # Cycle the log at 2GB
-      Cosmos::System.paths['DART_DATA']) # Log into the DART_DATA dir
-
-    hs_packet = Cosmos::System.telemetry.packet("INST", "HEALTH_STATUS")
-    @hs_packets = []
-    # Write packets. The first packet is always SYSTEM META.
-    num_pkts.times do
-      hs_packet.received_time = Time.now
-      @hs_packets << hs_packet.clone
-      writer.write(hs_packet)
-      sleep 0.01
-    end
-    writer.shutdown
-  end
-
-  describe "read" do
-    it "reads from the server" do
-      start_time = Time.now
-      load_db(3) # Load the DB with 3 packets
-      end_time = Time.now
-
-      i = DartTcpipServerInterface.new
-      i.connect
-
-      request_packet = Cosmos::Packet.new('DART', 'DART')
-      request_packet.define_item('REQUEST', 0, 0, :BLOCK)
-      request = {}
-      request['start_time_sec'] = start_time.tv_sec
-      request['start_time_usec'] = start_time.tv_usec
-      request['end_time_sec'] = end_time.tv_sec
-      request['end_time_usec'] = end_time.tv_usec
-      request['cmd_tlm'] = 'TLM'
-      request['packets'] = [['INST', 'HEALTH_STATUS']]
-      #~ request['meta_ids'] = [4962]
-      request_packet.write('REQUEST', JSON.dump(request))
-
-      interface = Cosmos::TcpipClientInterface.new(
-        Cosmos::System.connect_hosts['DART_STREAM'],
-        Cosmos::System.ports['DART_STREAM'],
-        Cosmos::System.ports['DART_STREAM'],
-        10, 10, 'PREIDENTIFIED')
-      interface.connect
-      interface.write(request_packet)
-      # The first packet read is SYSTEM META
-      packet = interface.read
-      expect(packet.target_name).to eq "SYSTEM"
-      expect(packet.packet_name).to eq "META"
-      packet = interface.read
-      # Verify the three INST HEALTH_STATUS packets match their original times
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[0].received_time
-      packet = interface.read
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[1].received_time
-      packet = interface.read
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[2].received_time
-      # After three packets are read we get back nil
-      packet = interface.read
-      expect(packet).to be nil
-
-      i.disconnect
-    end
-
-    it "reads packets between the start and end times" do
-      load_db(5) # Load the DB with 5 packets
-      # Set the start time after the first HEALTH_STATUS packet
-      start_time = @hs_packets[0].received_time + 0.005
-      # Set the end time before the last HEALTH_STATUS packet
-      end_time = @hs_packets[4].received_time - 0.005
-
-      i = DartTcpipServerInterface.new
-      i.connect
-
-      request_packet = Cosmos::Packet.new('DART', 'DART')
-      request_packet.define_item('REQUEST', 0, 0, :BLOCK)
-      request = {}
-      request['start_time_sec'] = start_time.tv_sec
-      request['start_time_usec'] = start_time.tv_usec
-      request['end_time_sec'] = end_time.tv_sec
-      request['end_time_usec'] = end_time.tv_usec
-      request['cmd_tlm'] = 'TLM'
-      request['packets'] = [['INST', 'HEALTH_STATUS']]
-      #~ request['meta_ids'] = [4962]
-      request_packet.write('REQUEST', JSON.dump(request))
-
-      interface = Cosmos::TcpipClientInterface.new(
-        Cosmos::System.connect_hosts['DART_STREAM'],
-        Cosmos::System.ports['DART_STREAM'],
-        Cosmos::System.ports['DART_STREAM'],
-        10, 10, 'PREIDENTIFIED')
-      interface.connect
-      interface.write(request_packet)
-      # The first packet read is SYSTEM META
-      packet = interface.read
-      expect(packet.target_name).to eq "SYSTEM"
-      expect(packet.packet_name).to eq "META"
-      packet = interface.read
-      # Verify the three INST HEALTH_STATUS packets match their original times
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[1].received_time
-      packet = interface.read
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[2].received_time
-      packet = interface.read
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[3].received_time
-      # After three packets are read we get back nil
-      packet = interface.read
-      expect(packet).to be nil
-
-      i.disconnect
-    end
-
-    it "returns packet in reverse order if start time is after end time" do
-      load_db(5) # Load the DB with 5 packets
-      # Set the end time after the first HEALTH_STATUS packet
-      end_time = @hs_packets[0].received_time + 0.005
-      # Set the start time before the last HEALTH_STATUS packet
-      start_time = @hs_packets[4].received_time - 0.005
-
-      i = DartTcpipServerInterface.new
-      i.connect
-
-      request_packet = Cosmos::Packet.new('DART', 'DART')
-      request_packet.define_item('REQUEST', 0, 0, :BLOCK)
-      request = {}
-      request['start_time_sec'] = start_time.tv_sec
-      request['start_time_usec'] = start_time.tv_usec
-      request['end_time_sec'] = end_time.tv_sec
-      request['end_time_usec'] = end_time.tv_usec
-      request['cmd_tlm'] = 'TLM'
-      request['packets'] = [['INST', 'HEALTH_STATUS']]
-      #~ request['meta_ids'] = [4962]
-      request_packet.write('REQUEST', JSON.dump(request))
-
-      interface = Cosmos::TcpipClientInterface.new(
-        Cosmos::System.connect_hosts['DART_STREAM'],
-        Cosmos::System.ports['DART_STREAM'],
-        Cosmos::System.ports['DART_STREAM'],
-        10, 10, 'PREIDENTIFIED')
-      interface.connect
-      interface.write(request_packet)
-      # The first packet read is SYSTEM META
-      packet = interface.read
-      expect(packet.target_name).to eq "SYSTEM"
-      expect(packet.packet_name).to eq "META"
-      packet = interface.read
-      # Verify the three INST HEALTH_STATUS packets match their original times
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[3].received_time
-      packet = interface.read
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[2].received_time
-      packet = interface.read
-      expect(packet.target_name).to eq "INST"
-      expect(packet.packet_name).to eq "HEALTH_STATUS"
-      expect(packet.received_time).to eq @hs_packets[1].received_time
-      # After three packets are read we get back nil
-      packet = interface.read
-      expect(packet).to be nil
-
-      i.disconnect
-    end
-  end
-end

data/lib/cosmos/dart/spec/rails_helper.rb

@@ -1,60 +0,0 @@
-# This file is copied to spec/ when you run 'rails generate rspec:install'
-# Set the user path to our COSMOS configuration in the spec directory
-ENV['COSMOS_USERPATH'] = File.join(File.dirname(File.expand_path(__FILE__)), '../../../../spec/install')
-
-require 'spec_helper'
-ENV['RAILS_ENV'] ||= 'test'
-require File.expand_path('../../config/environment', __FILE__)
-# Prevent database truncation if the environment is production
-abort("The Rails environment is running in production mode!") if Rails.env.production?
-require 'rspec/rails'
-# Add additional requires below this line. Rails is not loaded until this point!
-
-# Requires supporting ruby files with custom matchers and macros, etc, in
-# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
-# run as spec files by default. This means that files in spec/support that end
-# in _spec.rb will both be required and run as specs, causing the specs to be
-# run twice. It is recommended that you do not name files matching this glob to
-# end with _spec.rb. You can configure this pattern with the --pattern
-# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
-#
-# The following line is provided for convenience purposes. It has the downside
-# of increasing the boot-up time by auto-requiring all files in the support
-# directory. Alternatively, in the individual `*_spec.rb` files, manually
-# require only the support files necessary.
-#
-# Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
-
-# Checks for pending migrations and applies them before tests are run.
-# If you are not using ActiveRecord, you can remove this line.
-ActiveRecord::Migration.maintain_test_schema!
-
-RSpec.configure do |config|
-  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
-  config.fixture_path = "#{::Rails.root}/spec/fixtures"
-
-  # If you're not using ActiveRecord, or you'd prefer not to run each of your
-  # examples within a transaction, remove the following line or assign false
-  # instead of true.
-  config.use_transactional_fixtures = true
-
-  # RSpec Rails can automatically mix in different behaviours to your tests
-  # based on their file location, for example enabling you to call `get` and
-  # `post` in specs under `spec/controllers`.
-  #
-  # You can disable this behaviour by removing the line below, and instead
-  # explicitly tag your specs with their type, e.g.:
-  #
-  #     RSpec.describe UsersController, :type => :controller do
-  #       # ...
-  #     end
-  #
-  # The different available types are documented in the features, such as in
-  # https://relishapp.com/rspec/rspec-rails/docs
-  config.infer_spec_type_from_file_location!
-
-  # Filter lines from Rails gems in backtraces.
-  config.filter_rails_from_backtrace!
-  # arbitrary gems may also be filtered via:
-  # config.filter_gems_from_backtrace("gem name")
-end