fog-aws 3.12.0 → 3.14.0

data/tests/models/rds/server_tests.rb

@@ -1,131 +0,0 @@
-Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
-  model_tests(Fog::AWS[:rds].servers, rds_default_server_params) do
-    # We'll need this later; create it early to avoid waiting
-    @instance_with_final_snapshot = Fog::AWS[:rds].servers.create(rds_default_server_params.merge(:id => uniq_id("fog-snapshot-test"), :backup_retention_period => 1))
-    @instance_with_encrypted_storage = Fog::AWS[:rds].servers.create(rds_default_server_params.merge(:storage_encrypted => true))
-
-    @instance.wait_for(20*60) { ready? }
-    @instance_with_encrypted_storage.wait_for(20*60) { ready? }
-    @final_snapshot_id = uniq_id('fog-test-snapshot')
-
-    tests("#storage_encrypted") do
-      returns(true) { @instance_with_encrypted_storage.storage_encrypted }
-    end
-
-    test('#read_replica_identifiers is []') do
-      returns([]) { @instance.read_replica_identifiers }
-    end
-
-    tests('#snapshots') do
-      snapshot = nil
-
-      tests('#create').succeeds do
-        snapshot = @instance.snapshots.create(:id => uniq_id('fog-snapshot-test'))
-      end
-
-      snapshot.wait_for { ready?}
-
-      @instance.wait_for { ready? }
-
-      returns(true) { @instance.snapshots.map{ |s| s.id }.include?(snapshot.id) }
-      snapshot.destroy
-    end
-
-    tests("#modify").succeeds do
-      pending if Fog.mocking?
-
-      engine  = rds_default_server_params.fetch(:engine)
-      version = rds_default_server_params.fetch(:version).match(/\d+\.\d+/).to_s
-
-      orig_parameter_group = @instance.db_parameter_groups.first['DBParameterGroupName']
-      parameter_group = Fog::AWS[:rds].parameter_groups.create(:id => uniq_id, :family => "#{engine}#{version}", :description => 'fog-test')
-
-      orig_security_groups = @instance.db_security_groups.map{|h| h['DBSecurityGroupName']}
-      security_group = Fog::AWS[:rds].security_groups.create(:id => uniq_id, :description => 'fog-test')
-
-      modify_options = {
-        'DBParameterGroupName' => parameter_group.id,
-        'DBSecurityGroups' => orig_security_groups + [security_group.id]
-      }
-
-      @instance.modify(true, modify_options)
-      @instance.wait_for { ready? }
-
-      returns(parameter_group.id, 'new parameter group') do
-        @instance.db_parameter_groups.first['DBParameterGroupName']
-      end
-
-      returns(true, "new security group") do
-        @instance.db_security_groups.any?{|hash| hash['DBSecurityGroupName'] == security_group.id}
-      end
-
-      @instance.reboot
-      @instance.wait_for { state == 'rebooting' }
-      @instance.wait_for { ready? }
-
-      # Restore back to original state using symbols
-      restore_options = {
-       :parameter_group_name => orig_parameter_group,
-       :security_group_names => orig_security_groups
-      }
-      @instance.modify(true, restore_options)
-
-      @instance.reboot
-      @instance.wait_for { state == 'rebooting' }
-      @instance.wait_for do
-        ready? &&
-          db_security_groups.all? {|hash| hash['Status'] == 'active'} &&
-          db_parameter_groups.all? {|hash| hash['ParameterApplyStatus'] == 'in-sync' }
-      end
-
-      parameter_group.destroy
-      security_group.destroy
-    end
-
-    tests("#reboot").succeeds do
-      @instance.reboot
-    end
-    @instance.wait_for { state == 'rebooting' }
-    @instance.wait_for { ready? }
-
-    replica = nil
-
-    tests('#create_read_replica').succeeds do
-      replica = @instance_with_final_snapshot.create_read_replica(uniq_id('fog-replica'))
-      @instance_with_final_snapshot.reload
-      returns([replica.id]) { @instance_with_final_snapshot.read_replica_identifiers }
-      returns(@instance_with_final_snapshot.id) { replica.read_replica_source }
-
-      replica.wait_for { ready? }
-
-      # FinalDBSnapshotIdentifier can not be specified when deleting a replica instance
-      raises(Fog::AWS::RDS::Error) { replica.destroy("foobar") }
-    end
-
-    tests('#promote_read_replica').succeeds do
-      replica.promote.wait_for { state != "modifying" }
-
-      replica.read_replica_source == nil
-    end
-
-    tests('#promote_read_replica', 'master').raises(Fog::AWS::RDS::Error) {
-      @instance_with_final_snapshot.promote
-    }
-
-    replica && replica.destroy
-
-    test("Destroying with a final snapshot") do
-
-      @instance_with_final_snapshot.wait_for { ready? }
-      @instance_with_final_snapshot.destroy(@final_snapshot_id)
-      returns(true, "Final snapshot created") do
-        @final_snapshot = Fog::AWS[:rds].snapshots.get(@final_snapshot_id)
-        !@final_snapshot.nil?
-      end
-
-      @final_snapshot.wait_for { ready? }
-      @final_snapshot.destroy
-    end
-
-  end
-end

data/tests/models/rds/servers_tests.rb

@@ -1,24 +0,0 @@
-Shindo.tests("AWS::RDS | servers", ['aws', 'rds']) do
-
-  collection_tests(Fog::AWS[:rds].servers, rds_default_server_params) do
-    @instance.wait_for { ready? }
-  end
-
-  tests("#restore").succeeds do
-    instance = Fog::AWS[:rds].servers.create(rds_default_server_params.merge(:id => uniq_id("fog-snapshot-test")))
-
-    snapshot_id = uniq_id('fog-snapshot-test')
-    @snapshot = instance.snapshots.create(:id => snapshot_id )
-    instance.destroy
-
-    db_name = uniq_id('fog-db-name')
-    @restore_instance = Fog::AWS[:rds].servers.restore('master_username' => instance.master_username, 'flavor_id' => 'db.m3.medium', 'source_snapshot_id' => snapshot_id, 'id' => uniq_id('restored-instance'))
-  end
-
-  if Fog.mocking? && @restore_instance.respond_to?(:ready?)
-    @restore_instance.wait_for { ready? }
-  end
-
-  @snapshot.destroy
-  @restore_instance.destroy
-end

data/tests/models/rds/snapshot_tests.rb

@@ -1,12 +0,0 @@
-Shindo.tests("AWS::RDS | snapshot", ['aws', 'rds']) do
-
-  @server = Fog::AWS[:rds].servers.create(rds_default_server_params)
-  @server.wait_for { ready? }
-
-  params = {:id => uniq_id, :instance_id => @server.id}
-  model_tests(Fog::AWS[:rds].snapshots, params) do
-    @instance.wait_for { ready? }
-  end
-
-  @server.destroy
-end

data/tests/models/rds/snapshots_tests.rb

@@ -1,12 +0,0 @@
-Shindo.tests("AWS::RDS | snapshots", ['aws', 'rds']) do
-
-  @server = Fog::AWS[:rds].servers.create(rds_default_server_params)
-  @server.wait_for { ready? }
-
-  params = {:id => uniq_id, :instance_id => @server.id}
-  collection_tests(Fog::AWS[:rds].snapshots, params) do
-    @instance.wait_for { ready? }
-  end
-
-  @server.destroy
-end

data/tests/models/rds/tagging_tests.rb

@@ -1,20 +0,0 @@
-Shindo.tests("AWS::RDS | tagging", ['aws', 'rds']) do
-
-  @server = Fog::AWS[:rds].servers.create(rds_default_server_params)
-  Fog::Formatador.display_line "Creating RDS instance #{@server.id}"
-  Fog::Formatador.display_line "Waiting for instance #{@server.id} to be ready"
-  @server.wait_for { ready? }
-
-  tags1 = {'key1' => 'val1'}
-  tags2 = {'key2' => 'val2'}
-
-  tests "add and remove tags from a running RDS model" do
-    returns({})                 { @server.tags }
-    returns(tags1)              { @server.add_tags tags1 }
-    returns(tags1.merge tags2)  { @server.add_tags tags2 }
-    returns(tags2)              { @server.remove_tags tags1.keys  }
-    returns(tags2)              { @server.tags }
-  end
-
-  @server.destroy
-end

data/tests/models/sns/topic_tests.rb

@@ -1,15 +0,0 @@
-Shindo.tests("AWS::SNS | topic", ['aws', 'sns']) do
-  params = {:id => 'fog'}
-
-  model_tests(Fog::AWS[:sns].topics, params) do
-    @instance.wait_for { ready? }
-
-    tests("#display_name").returns('fog') { @instance.display_name }
-
-    tests("#update_topic_attribute") do
-      @instance.update_topic_attribute("DisplayName", "new-fog")
-
-      tests("#display_name").returns('new-fog') { @instance.display_name }
-    end
-  end
-end

data/tests/models/sns/topics_tests.rb

@@ -1,6 +0,0 @@
-Shindo.tests("AWS::SNS | topics", ['aws', 'sns']) do
-  pending unless Fog.mocking?
-  params = {:id => 'arn:aws:sns:us-east-1:12345678910:fog'}
-
-  collection_tests(Fog::AWS[:sns].topics, params)
-end

data/tests/models/storage/directory_tests.rb

@@ -1,202 +0,0 @@
-Shindo.tests("Storage[:aws] | directory", ["aws"]) do
-  tests('Fog::Storage[:aws]', "#request_params") do
-    def slice(hash, *args)
-      hash.select { |k, _| args.include?(k) }
-    end
-
-    instance = Fog::Storage[:aws]
-    method = instance.method(:request_params)
-
-    params = {bucket_name: 'profile-uploads', host: 'profile-uploads.s3.us-west-2.amazonaws.com'}
-    tests("given #{params}, request_params[:host]").returns("profile-uploads.s3.us-west-2.amazonaws.com") do
-      method.call(params)[:host]
-    end
-
-    params = {bucket_name: 'profile-uploads.johnsmith.net', cname: 'profile-uploads.johnsmith.net', virtual_host: true}
-    tests("given #{params}, request_params[:host]").returns("profile-uploads.johnsmith.net") do
-      method.call(params)[:host]
-    end
-
-    params = {bucket_name: 'profile-uploads.johnsmith.net', cname: 'profile-uploads.johnsmith.net', virtual_host: false}
-    tests("given #{params}, request_params[:host], request_params[:path]").
-      returns({host: "s3.amazonaws.com", path: "/profile-uploads.johnsmith.net/"}) do
-      slice(method.call(params), :host, :path)
-    end
-
-    params = {bucket_name: 'profile-uploads.johnsmith.net', bucket_cname: 'profile-uploads.johnsmith.net'}
-    tests("given #{params}, request_params[:host]").returns("profile-uploads.johnsmith.net") do
-      method.call(params)[:host]
-    end
-
-    params = {bucket_name: 'profile-uploads'}
-    tests("given #{params}, request_params[:path], request_params[:host]").
-      returns({path: "/", host: "profile-uploads.s3.amazonaws.com"}) do
-        slice(method.call(params), :path, :host)
-      end
-
-    params = {bucket_name: 'profile-uploads', path_style: true}
-    tests("given #{params}, request_params[:path], request_params[:host]").
-      returns({path: "/profile-uploads/", host: "s3.amazonaws.com"}) do
-        slice(method.call(params), :path, :host)
-      end
-
-    params = {bucket_name: 'profile-uploads', path_style: false}
-    tests("given #{params}, request_params[:path], request_params[:host]").
-      returns({path: "/", host: "profile-uploads.s3.amazonaws.com"}) do
-        slice(method.call(params), :path, :host)
-      end
-
-    params = {scheme: 'https', bucket_name: 'profile.uploads', path_style: false}
-    tests("given #{params}, request_params[:path], request_params[:host]").
-      returns(path: "/profile.uploads/", host: "s3.amazonaws.com") do
-        slice(method.call(params), :path, :host)
-      end
-
-    params = {:headers=>{:"Content-Type"=>"application/json"}}
-    tests("given #{params}, request_params[:headers]").returns({:"Content-Type"=>"application/json"}) do
-      method.call(params)[:headers]
-    end
-
-    params = {headers: {}}
-    tests("given #{params}, request_params[:headers]").returns({}) do
-      method.call(params)[:headers]
-    end
-
-    params = {scheme: 'http'}
-    tests("given #{params}, request_params[:scheme]").returns('http') do
-      method.call(params)[:scheme]
-    end
-
-    params = {}
-    tests("given #{params}, request_params[:scheme]").returns('https') do
-      method.call(params)[:scheme]
-    end
-
-    params = {scheme: 'http', port: 8080}
-    tests("given #{params} (default scheme), request_params[:port]").returns(8080) do
-      method.call(params)[:port]
-    end
-
-    params = {scheme: 'https', port: 443}
-    tests("given #{params}, request_params[:port]").returns(nil) do
-      method.call(params)[:port]
-    end
-
-    params = {}
-    tests("given #{params}, request_params[:host]").returns("s3.amazonaws.com") do
-      method.call(params)[:host]
-    end
-
-    params = {region: 'us-east-1'}
-    tests("given #{params}, request_params[:host]").returns("s3.amazonaws.com") do
-      method.call(params)[:host]
-    end
-
-    params = {region: 'us-west-2'}
-    tests("given #{params}, request_params[:host]").returns("s3.us-west-2.amazonaws.com") do
-      method.call(params)[:host]
-    end
-
-    params= {region: 'us-east-1', host: 's3.us-west-2.amazonaws.com'}
-    tests("given #{params}, request_params[:host]").returns("s3.us-west-2.amazonaws.com") do
-      method.call(params)[:host]
-    end
-
-    params = {object_name: 'image.png'}
-    tests("given #{params}, request_params[:host]").returns("/image.png") do
-      method.call(params)[:path]
-    end
-
-    params = {object_name: 'image.png', path: '/images/image.png'}
-    tests("given #{params}, request_params[:host]").returns("/images/image.png") do
-      method.call(params)[:path]
-    end
-  end
-
-  directory_attributes = {
-    :key => uniq_id('fogdirectorytests')
-  }
-
-  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
-    tests("#public_url").returns(nil) do
-      @instance.public_url
-    end
-
-    tests('#location').returns('us-east-1') do # == Fog::AWS::Storage::DEFAULT_REGION
-      @instance.location
-    end
-
-    @instance.acl = 'public-read'
-    @instance.save
-
-    tests("#public_url").returns(true) do
-      if @instance.public_url =~ %r[\Ahttps://fogdirectorytests-[\da-f]+\.s3\.amazonaws\.com/\z]
-        true
-      else
-        @instance.public_url
-      end
-    end
-  end
-
-  directory_attributes = {
-    :key => uniq_id('different-region'),
-    :location => 'eu-west-1',
-  }
-
-  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
-    tests("#location").returns('eu-west-1') do
-      @instance.location
-    end
-
-    tests("#location").returns('eu-west-1') do
-      Fog::Storage[:aws].directories.get(@instance.identity).location
-    end
-  end
-
-  directory_attributes = {
-    :key => uniq_id('fogdirectorytests')
-  }
-
-  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
-
-    tests("#versioning=") do
-      tests("#versioning=(true)").succeeds do
-        @instance.versioning = true
-      end
-
-      tests("#versioning=(true) sets versioning to 'Enabled'").returns('Enabled') do
-        @instance.versioning = true
-        @instance.service.get_bucket_versioning(@instance.key).body['VersioningConfiguration']['Status']
-      end
-
-      tests("#versioning=(false)").succeeds do
-        (@instance.versioning = false).equal? false
-      end
-
-      tests("#versioning=(false) sets versioning to 'Suspended'").returns('Suspended') do
-        @instance.versioning = false
-        @instance.service.get_bucket_versioning(@instance.key).body['VersioningConfiguration']['Status']
-      end
-    end
-
-  end
-
-  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
-
-    tests("#versioning?") do
-      tests("#versioning? false if not enabled").returns(false) do
-        @instance.versioning?
-      end
-
-      tests("#versioning? true if enabled").returns(true) do
-        @instance.service.put_bucket_versioning(@instance.key, 'Enabled')
-        @instance.versioning?
-      end
-
-      tests("#versioning? false if suspended").returns(false) do
-        @instance.service.put_bucket_versioning(@instance.key, 'Suspended')
-        @instance.versioning?
-      end
-    end
-  end
-end

data/tests/models/storage/file_tests.rb

@@ -1,129 +0,0 @@
-Shindo.tests("Storage[:aws] | file", ["aws"]) do
-
-  require 'tempfile'
-
-  file_attributes = {
-    :key => 'fog_file_tests',
-    :body => lorem_file,
-    :public => true
-  }
-
-  directory_attributes = {
-    :key => uniq_id("fogfilestests")
-  }
-
-  @directory = Fog::Storage[:aws].directories.create(directory_attributes)
-
-  model_tests(@directory.files, file_attributes, Fog.mocking?) do
-
-    tests("#version") do
-      tests("#version should be null if versioning isn't enabled").returns(nil) do
-        @instance.version
-      end
-    end
-
-  end
-
-  @directory.versioning = true
-
-  model_tests(@directory.files, file_attributes, Fog.mocking?) do
-
-    tests("#version") do
-      tests("#version should not be null if versioning is enabled").returns(false) do
-        @instance.version == nil
-      end
-    end
-
-    @directory.files.create(:key => @instance.key)
-    @instance.destroy
-
-    tests("#versions") do
-      tests('#versions.size includes versions (including DeleteMarkers) for all keys').returns(3) do
-        @instance.versions.size
-      end
-
-      tests('#versions are all for the correct key').returns(true) do
-        @instance.versions.all? { |v| v.key == @instance.key }
-      end
-    end
-
-    tests("#destroy") do
-      tests("#destroy a specific version should delete the version, not create a DeleteMarker").returns(2) do
-        @instance.destroy('versionId' => @instance.version)
-        @instance.versions.all.size
-      end
-    end
-
-    tests("multipart upload") do
-      pending if Fog.mocking?
-
-      # A 6MB file
-      @large_file = Tempfile.new("fog-test-aws-s3-multipart")
-      6.times { @large_file.write("x" * (1024**2)) }
-      @large_file.rewind
-
-      tests("#save(:multipart_chunk_size => 5242880)").succeeds do
-        @directory.files.create(:key => 'multipart-upload', :body => @large_file, :multipart_chunk_size => 5242880)
-      end
-
-      @large_file.close
-
-    end
-
-    tests("multipart upload with empty file") do
-      pending if Fog.mocking?
-
-      @empty_file = Tempfile.new("fog-test-aws-s3-multipart-empty")
-     
-      tests("#save(:multipart_chunk_size => 5242880)").succeeds do
-        @directory.files.create(:key => 'empty-multipart-upload', :body => @empty_file, :multipart_chunk_size => 5242880)
-      end
-
-      @empty_file.close
-    end
-
-    tests("multipart upload with customer encryption").returns(true) do
-      pending if Fog.mocking?
-
-      encryption_key = OpenSSL::Cipher.new("AES-256-ECB").random_key
-
-      # A 6MB file
-      @large_file = Tempfile.new("fog-test-aws-s3-multipart")
-      6.times { @large_file.write("x" * (1024**2)) }
-      @large_file.rewind
-
-      tests("#save(:multipart_chunk_size => 5242880)").succeeds do
-        @directory.files.create(
-          :key => 'multipart-encrypted-upload',
-          :body => @large_file,
-          :multipart_chunk_size => 5242880,
-          :encryption => "AES256",
-          :encryption_key => encryption_key
-        )
-      end
-
-      @large_file.close
-
-      @directory.files.get('multipart-encrypted-upload',
-        'x-amz-server-side-encryption-customer-algorithm' => 'AES256',
-        'x-amz-server-side-encryption-customer-key' => Base64.encode64(encryption_key).chomp!,
-        'x-amz-server-side-encryption-customer-key-MD5' => Base64.encode64(OpenSSL::Digest::MD5.digest(encryption_key.to_s)).chomp!
-      ).body == "x" * 6*1024**2
-    end
-
-    acl = Fog::Storage[:aws].get_object_acl(@directory.key, @instance.key).body["AccessControlList"]
-
-    tests("#acl").returns(acl) do
-      @instance.acl
-    end
-
-    tests("#public?").returns(acl.any? {|grant| grant['Grantee']['URI'] == 'http://acs.amazonaws.com/groups/global/AllUsers' && grant['Permission'] == 'READ'}) do
-      @instance.public?
-    end
-
-  end
-
-  @directory.versions.each(&:destroy)
-  @directory.destroy
-
-end

data/tests/models/storage/files_tests.rb

@@ -1,90 +0,0 @@
-Shindo.tests("Storage[:aws] | files", ["aws"]) do
-
-  file_attributes = {
-      :key => 'fog_file_tests',
-      :body => lorem_file,
-      :public => true
-  }
-
-  directory_attributes = {
-      :key => uniq_id('fogfilestests')
-  }
-
-  @directory = Fog::Storage[:aws].directories.create(directory_attributes)
-  @directory.versioning = true
-
-  model_tests(@directory.files, file_attributes, Fog.mocking?) do
-
-    v1 = @instance.version
-    v2 = @directory.service.put_object(@directory.key, @instance.key, 'version 2 content').headers['x-amz-version-id']
-    v3 = @directory.service.delete_object(@directory.key, @instance.key).headers['x-amz-version-id']
-    v4 = @directory.service.put_object(@directory.key, @instance.key, 'version 3 content').headers['x-amz-version-id']
-
-    tests("#get") do
-      tests("#get without version fetches the latest version").returns(v4) do
-        @directory.files.get(@instance.key).version
-      end
-
-      tests("#get with version fetches that exact version").returns(v2) do
-        @directory.files.get(@instance.key, 'versionId' => v2).version
-      end
-
-      tests("#get with a deleted version returns nil").returns(nil) do
-        pending # getting 405 Method Not Allowed
-        @directory.files.get(@instance.key, 'versionId' => v3)
-      end
-    end
-
-    tests("#head") do
-      tests("#head without version fetches the latest version").returns(v4) do
-        @directory.files.head(@instance.key).version
-      end
-
-      tests("#head with version fetches that exact version").returns(v2) do
-        @directory.files.head(@instance.key, 'versionId' => v2).version
-      end
-
-      tests("#head with a deleted version returns nil").returns(nil) do
-        pending # getting 405 Method Not Allowed
-        @directory.files.head(@instance.key, 'versionId' => v3)
-      end
-    end
-
-    tests('#normalize_headers') do
-      files = @directory.files
-      response = Excon::Response.new
-      current_time = Time.new(2021, 02, 21)
-
-      response.headers['last-modified'] = current_time.to_s
-      response.headers['etag'] = '12345'
-      response.headers['ETAG'] = '12345'
-      response.headers['Cache-Control'] = 'no-cache'
-      response.headers['Content-disposition'] = 'attachment'
-      response.headers['content-length'] = 100
-      response.headers['content-Encoding'] = 'gzip'
-      response.headers['content-md5'] = 'ABCDEAB'
-      response.headers['content-Md5'] = 'ABCDEAB'
-      response.headers['ConTent-Type'] = 'application/json'
-
-      expected = {
-        'Last-Modified' => current_time,
-        'ETag' => '12345',
-        'Cache-Control' => 'no-cache',
-        'Content-Disposition' => 'attachment',
-        'Content-Length' => 100,
-        'Content-Encoding' => 'gzip',
-        'Content-MD5' => 'ABCDEAB',
-        'Content-Type' => 'application/json'
-      }
-
-      tests('header keys are normalized').returns(expected) do
-        files.normalize_headers(response)
-        response.headers
-      end
-    end
-  end
-
-  @directory.versions.each(&:destroy)
-  @directory.destroy
-
-end

data/tests/models/storage/url_tests.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-Shindo.tests('AWS | url', ["aws"]) do
-
-  @storage = Fog::Storage.new(
-    :provider => 'AWS',
-    :aws_access_key_id => '123',
-    :aws_secret_access_key => 'abc',
-    :region => 'us-east-1'
-  )
-
-  @file = @storage.directories.new(:key => 'fognonbucket').files.new(:key => 'test.txt')
-
-  now = Fog::Time.now
-  
-  @storage = Fog::Storage.new(
-    :provider => 'AWS',
-    :aws_access_key_id => '123',
-    :aws_secret_access_key => 'abc',
-    :aws_signature_version => 2,
-    :region => 'us-east-1'
-  )
-
-  @file = @storage.directories.new(:key => 'fognonbucket').files.new(:key => 'test.txt')
-
-end