bandwidth-sdk 10.5.0 → 11.0.0.pre.beta.1

data/spec/integration/mfa_api_integration_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'json'
+
+# Integration Tests for Bandwidth::MFAApi
+describe 'MFAApi Integration Tests' do
+  before(:all) do
+    Bandwidth.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+    end
+    @api_instance_mfa = Bandwidth::MFAApi.new
+  end
+
+  # Messaging Authentication Code
+  describe 'generate_messaging_code' do
+    it 'generates messaging mfa code' do
+      req_schema = Bandwidth::CodeRequest.new(
+        to: USER_NUMBER,
+        from: BW_NUMBER,
+        application_id: BW_MESSAGING_APPLICATION_ID,
+        message: "Your temporary {NAME} {SCOPE} code is: {CODE}",
+        digits: 6
+      )
+      response = @api_instance_mfa.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA]).to be_instance_of(Bandwidth::MessagingCodeResponse)
+      expect(response[DATA].message_id.length).to eq(29)
+    end
+  end
+
+  # Voice Authentication Code
+  describe 'generate_voice_code' do
+    it 'generates voice mfa code' do
+      req_schema = Bandwidth::CodeRequest.new(
+        to: USER_NUMBER,
+        from: BW_NUMBER,
+        application_id: BW_VOICE_APPLICATION_ID,
+        message: "Your temporary {NAME} {SCOPE} code is: {CODE}",
+        digits: 6
+      )
+      response = @api_instance_mfa.generate_voice_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA]).to be_instance_of(Bandwidth::VoiceCodeResponse)
+      expect(response[DATA].call_id.length).to eq(47)
+    end
+  end
+
+  # Verify Authentication Code
+  describe 'verify_code' do
+    it 'verifies mfa code' do
+      req_schema = Bandwidth::VerifyCodeRequest.new(
+        to: "+1000" + rand(1...10000000).to_s,
+        scope: "2FA",
+        expiration_time_in_minutes: 3,
+        code: "12345"
+      )
+      response = @api_instance_mfa.verify_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA]).to be_instance_of(Bandwidth::VerifyCodeResponse)
+      expect(response[DATA].valid).to be_instance_of(FalseClass)
+    end
+  end
+
+  # HTTP 4XX Errors
+  describe 'http error' do
+    it 'causes a 400 error' do
+      req_schema = Bandwidth::CodeRequest.new(
+        to: USER_NUMBER,
+        from: BW_NUMBER,
+        application_id: "not_an_application_id",
+        message: "Your temporary {NAME} {SCOPE} code is: {CODE}",
+        digits: 6
+      )
+
+      expect {
+        response = @api_instance_mfa.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(400)
+      }
+    end
+
+    it 'causes a 403 error' do
+      Bandwidth.configure do |config|
+        config.username = 'bad_username'
+        config.password = 'bad_password'
+      end
+
+      req_schema = Bandwidth::CodeRequest.new(
+        to: USER_NUMBER,
+        from: BW_NUMBER,
+        application_id: BW_MESSAGING_APPLICATION_ID,
+        message: "Your temporary {NAME} {SCOPE} code is: {CODE}",
+        digits: 6
+      )
+      
+      expect {
+        response = @api_instance_mfa.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(403)
+      }
+    end
+  end
+
+end

data/spec/integration/phone_number_lookup_api_integration_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'json'
+
+# Integration Tests for Bandwidth::PhoneNumberLookupApi
+describe 'PhoneNumberLookupApi Integration Tests' do
+  before(:all) do
+    Bandwidth.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+    end
+    @api_instance_tnlookup = Bandwidth::PhoneNumberLookupApi.new
+    $lookup_request_id = ""
+  end
+
+  # Create Lookup
+  describe 'create_lookup' do
+    it 'creates a tn lookup request' do
+      tn_body = Bandwidth::LookupRequest.new(
+        tns: [BW_NUMBER]
+      )
+      response = @api_instance_tnlookup.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body)
+
+      expect(response[CODE]).to eq(202)
+      expect(response[DATA]).to be_instance_of(Bandwidth::CreateLookupResponse)
+      expect(response[DATA].request_id.length).to eq(36)
+      expect(response[DATA].status).to be_instance_of(String)
+
+      $lookup_request_id  = response[DATA].request_id
+      sleep(1)
+    end
+  end
+
+  # Get Lookup Status
+  describe 'get_lookup_status' do
+    it 'gets lookup status' do
+      response = @api_instance_tnlookup.get_lookup_status_with_http_info(BW_ACCOUNT_ID, $lookup_request_id)
+
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA]).to be_instance_of(Bandwidth::LookupStatus)
+      expect(response[DATA].request_id).to eq($lookup_request_id)
+      expect(response[DATA].status).to be_instance_of(String)
+      expect(response[DATA].result[0].response_code).to be_instance_of(Integer)
+      expect(response[DATA].result[0].e_164_format).to eq(BW_NUMBER)
+    end
+  end
+
+  # HTTP 4XX Errors
+  describe 'http error' do
+    it 'causes a 400 error' do
+      tn_body_bad = Bandwidth::LookupRequest.new(
+        tns: ["+1invalid"]
+      )
+
+      expect {
+        @api_instance_tnlookup.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body_bad)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(400)
+      }
+    end
+    
+    it 'causes a 404 error' do
+      req_id_dne = "12345678-abcd-cdef-9876-12345678abcd"
+
+      expect {
+        @api_instance_tnlookup.get_lookup_status_with_http_info(BW_ACCOUNT_ID, req_id_dne)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(404)
+      }
+    end
+
+    it 'causes a 401 error' do
+      Bandwidth.configure do |config|
+        config.username = 'bad_username'
+        config.password = 'bad_password'
+      end
+
+      tn_body = Bandwidth::LookupRequest.new(
+        tns: [BW_NUMBER]
+      )
+
+      expect {
+        @api_instance_tnlookup.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(401)
+      }
+    end
+  end
+
+end

data/spec/integration/recordings_api_integration_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+require 'json'
+require_relative '../call_utils'
+
+# Integration Tests for Bandwidth::RecordingsApi
+describe 'RecordingsApi Integration Tests' do
+  before(:all) do
+    Bandwidth.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+      config.return_binary_data = true
+    end
+    @api_instance_recordings = Bandwidth::RecordingsApi.new
+    @api_instance_calls = Bandwidth::CallsApi.new
+    $manteca_test_id = setup_manteca('CALL')
+    $manteca_call_id = create_manteca_call($manteca_test_id, "/bxml/startLongRecording", @api_instance_calls)
+    $recording_id = ""
+  end
+ 
+  # Update Recording
+  describe 'update_call_recording_state' do
+    it 'updates and ends the manteca call recording' do
+      pause_recording = Bandwidth::UpdateCallRecording.new(
+        state: Bandwidth::RecordingStateEnum::PAUSED
+      )
+
+      start_recording = Bandwidth::UpdateCallRecording.new(
+        state: Bandwidth::RecordingStateEnum::RECORDING
+      )
+
+      sleep(SLEEP_TIME_S * 2)
+      pause_response = @api_instance_recordings.update_call_recording_state_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, pause_recording)
+      expect(pause_response[CODE]).to eq(200)
+
+      sleep(SLEEP_TIME_S)
+      record_response = @api_instance_recordings.update_call_recording_state_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, start_recording)
+      expect(record_response[CODE]).to eq(200)
+
+      complete_response = @api_instance_calls.update_call_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $complete_call_body)
+      expect(complete_response[CODE]).to eq(200)
+
+      retries = 0
+      recording_complete = false
+      begin
+        while !recording_complete && retries < MAX_RETRIES
+          recording_complete = get_manteca_test_status($manteca_test_id)["callRecorded"]
+          retries += 1
+          sleep(SLEEP_TIME_S)
+        end
+      rescue => e
+        puts e.inspect
+      end
+
+      expect(recording_complete).to be_instance_of(TrueClass)
+    end
+  end
+  
+  # Get Call Recordings
+  describe 'list_account_call_recordings' do
+    it 'lists account call recordings' do
+      response = @api_instance_recordings.list_account_call_recordings_with_http_info(BW_ACCOUNT_ID)
+
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA][0]).to be_instance_of(Bandwidth::CallRecordingMetadata)
+      expect(response[DATA][0].application_id).to eq(MANTECA_APPLICATION_ID)
+      expect(response[DATA][0].account_id).to eq(BW_ACCOUNT_ID)
+    end
+  end
+
+  # List Call Recordings
+  describe 'list_call_recordings' do
+    it 'lists all recordings for a single call' do
+      response = @api_instance_recordings.list_call_recordings_with_http_info(BW_ACCOUNT_ID, $manteca_call_id)
+
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA][0]).to be_instance_of(Bandwidth::CallRecordingMetadata)
+      expect(response[DATA][0].application_id).to eq(MANTECA_APPLICATION_ID)
+      expect(response[DATA][0].account_id).to eq(BW_ACCOUNT_ID)
+      expect(response[DATA][0].call_id).to eq($manteca_call_id)
+      expect(response[DATA][0].recording_id).to be_instance_of(String)
+      expect(response[DATA][0].status).to eq('complete').or eq('partial')
+      
+      $recording_id = response[DATA][0].recording_id
+    end
+  end
+  
+  # Get Call Recording
+  describe 'get_call_recording' do
+    it 'gets a call recording by id' do
+      response = @api_instance_recordings.get_call_recording_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id)
+      
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA]).to be_instance_of(Bandwidth::CallRecordingMetadata)
+      expect(response[DATA].application_id).to eq(MANTECA_APPLICATION_ID)
+      expect(response[DATA].account_id).to eq(BW_ACCOUNT_ID)
+      expect(response[DATA].call_id).to eq($manteca_call_id)
+      expect(response[DATA].status).to eq('complete').or eq('partial')
+      expect(response[DATA].recording_id).to eq($recording_id)
+    end
+  end
+  
+    # Download Recording
+    describe 'download_call_recording' do
+      it 'downloads a call recording by id' do
+        response = @api_instance_recordings.download_call_recording_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id)
+
+        expect(response[CODE]).to eq(200)
+        expect(response[DATA]).to be_instance_of(String)
+      end
+    end
+  
+  # Create Transcription Request
+  describe 'transcribe_call_recording' do
+    it 'creates a transcription request' do
+      transcribe_recording = Bandwidth::TranscribeRecording.new(
+        callback_url: MANTECA_BASE_URL + "/transcriptions",
+        tag: $manteca_test_id
+      )
+
+      response = @api_instance_recordings.transcribe_call_recording_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id, transcribe_recording)
+      expect(response[CODE]).to eq(204)
+
+      retries = 0
+      transcription_complete = false
+      sleep(SLEEP_TIME_S * 10)
+      begin
+        while !transcription_complete && retries < MAX_RETRIES
+          transcription_complete = get_manteca_test_status($manteca_test_id)["callTranscribed"]
+          retries += 1
+          sleep(SLEEP_TIME_S)
+        end
+      rescue => e
+        puts e.inspect
+      end
+
+      expect(transcription_complete).to be_instance_of(TrueClass)
+    end
+  end
+  
+    # Get Transcription
+    describe 'get_call_transcription' do
+      it 'gets the completed call recording transcription' do
+        response = @api_instance_recordings.get_call_transcription_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id)
+
+        expect(response[CODE]).to eq(200)
+        expect(response[DATA]).to be_instance_of(Bandwidth::TranscriptionList)
+        expect(response[DATA].transcripts[0]).to be_instance_of(Bandwidth::Transcription)
+        expect(response[DATA].transcripts[0].text).to be_instance_of(String)
+        expect(response[DATA].transcripts[0].confidence).to be_instance_of(Float)
+      end
+    end
+
+  # Delete Transcription
+  describe 'delete_call_transcription' do
+    it 'deletes the completed call recording transcription' do
+      response = @api_instance_recordings.delete_call_transcription_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id)
+      expect(response[CODE]).to eq(204)
+    end
+  end
+  
+    # Delete Recording Media
+    describe 'delete_recording_media' do
+      it 'deletes the completed call recording media' do
+        response = @api_instance_recordings.delete_recording_media_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id)
+        expect(response[CODE]).to eq(204)
+      end
+    end
+
+  # Delete Recording
+  describe 'delete_recording' do
+    it 'deletes the completed call recording data' do
+      response = @api_instance_recordings.delete_recording_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id)
+      expect(response[CODE]).to eq(204)
+    end
+  end
+
+  # HTTP 4XX Errors
+  describe 'http error' do
+    it 'causes a 404 error' do
+      dne_id = "does-not-exist"
+
+      expect {
+        @api_instance_recordings.get_call_recording_with_http_info(BW_ACCOUNT_ID, dne_id, dne_id)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(404)
+      }
+    end
+
+    it 'causes a 401 error' do
+      Bandwidth.configure do |config|
+        config.username = 'bad_username'
+        config.password = 'bad_password'
+      end
+
+      expect {
+        @api_instance_recordings.get_call_recording_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(401)
+      }
+    end
+
+    it 'causes a 403 error' do
+      Bandwidth.configure do |config|
+        config.username = FORBIDDEN_USERNAME
+        config.password = FORBIDDEN_PASSWORD
+      end
+
+      expect {
+        @api_instance_recordings.get_call_recording_with_http_info(BW_ACCOUNT_ID, $manteca_call_id, $recording_id)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(403)
+      }
+    end
+  end
+
+end

data/spec/integration/statistics_api_integration_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'json'
+
+# Integration Tests for Bandwidth::StatisticsApi
+describe 'StatisticsApi Integration Tests' do
+  before(:all) do
+    Bandwidth.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+    end
+    @api_instance_statistics = Bandwidth::StatisticsApi.new
+  end
+
+  # Get Account Statistics
+  describe 'get_statistics' do
+    it 'gets account statistics' do
+      response = @api_instance_statistics.get_statistics_with_http_info(BW_ACCOUNT_ID)
+
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA]).to be_instance_of(Bandwidth::AccountStatistics)
+      expect(response[DATA].current_call_queue_size).to be_instance_of(Integer)
+      expect(response[DATA].max_call_queue_size).to eq(7500)
+    end
+  end
+
+  # HTTP 4XX Errors
+  describe 'http error' do
+    it 'causes a 401 error' do
+      Bandwidth.configure do |config|
+        config.username = 'bad_username'
+        config.password = 'bad_password'
+      end
+
+      expect {
+        @api_instance_statistics.get_statistics_with_http_info(BW_ACCOUNT_ID)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(401)
+      }
+    end
+
+    it 'causes a 403 error' do
+      Bandwidth.configure do |config|
+        config.username = FORBIDDEN_USERNAME
+        config.password = FORBIDDEN_PASSWORD
+      end
+
+      expect {
+        @api_instance_statistics.get_statistics_with_http_info(BW_ACCOUNT_ID)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(403)
+      }
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,154 @@
+=begin
+#Bandwidth
+
+#Bandwidth's Communication APIs
+
+The version of the OpenAPI document: 1.0.0
+Contact: letstalk@bandwidth.com
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 6.4.0
+
+=end
+
+# load the gem
+require 'bandwidth-sdk'
+
+# The following  was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.before(:suite) {
+    begin
+      BW_USERNAME = ENV.fetch("BW_USERNAME")
+      BW_PASSWORD = ENV.fetch("BW_PASSWORD")
+      FORBIDDEN_USERNAME = ENV.fetch("BW_USERNAME_FORBIDDEN")
+      FORBIDDEN_PASSWORD = ENV.fetch("BW_PASSWORD_FORBIDDEN")
+      BW_ACCOUNT_ID = ENV.fetch("BW_ACCOUNT_ID")
+      BW_VOICE_APPLICATION_ID = ENV.fetch("BW_VOICE_APPLICATION_ID")
+      BW_MESSAGING_APPLICATION_ID = ENV.fetch("BW_MESSAGING_APPLICATION_ID")
+      BASE_CALLBACK_URL = ENV.fetch("BASE_CALLBACK_URL")
+      BW_NUMBER = ENV.fetch("BW_NUMBER")
+      USER_NUMBER = ENV.fetch("USER_NUMBER")
+      MANTECA_ACTIVE_NUMBER = ENV.fetch("MANTECA_ACTIVE_NUMBER")
+      MANTECA_IDLE_NUMBER = ENV.fetch("MANTECA_IDLE_NUMBER")
+      MANTECA_BASE_URL = ENV.fetch("MANTECA_BASE_URL")
+      MANTECA_APPLICATION_ID = ENV.fetch("MANTECA_APPLICATION_ID")
+      OPERATING_SYSTEM = ENV.fetch("OPERATING_SYSTEM")
+      RUBY_VERSION = ENV.fetch("RUBY_VERSION")
+    rescue
+      puts "Environmental variables not found"
+      exit(-1)
+    end
+
+    DATA = 0    # index for response array related to the response data
+    CODE = 1    # index for response array related to the status code
+    SLEEP_TIME_S = 3  # default sleep time in seconds
+    MAX_RETRIES = 40
+    $active_calls = []
+
+    $complete_call_body = Bandwidth::UpdateCall.new(
+      state: Bandwidth::CallStateEnum::COMPLETED
+    )
+  }
+
+  config.after(:suite) {
+    Bandwidth.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+    end
+    calls_api = Bandwidth::CallsApi.new
+    cleanup_calls($active_calls, calls_api)
+  }
+  
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end